Restoring authorship annotation for <e-sidorov@yandex-team.ru>. Commit 1 of 2.

contrib/restricted/thrift/compiler/thrift/audit/t_audit.cpp

@@ -1,464 +1,464 @@
-
-#include <cassert>
-#include <stdlib.h>
-#include <stdio.h>
-#include <stdarg.h>
-#include <time.h>
-#include <string>
-#include <algorithm>
-#include <sys/types.h>
-#include <sys/stat.h>
-#include <errno.h>
-#include <limits.h>
-
-// Careful: must include globals first for extern definitions
-#include "thrift/globals.h"
-
-#include "thrift/parse/t_program.h"
-#include "thrift/parse/t_scope.h"
-#include "thrift/parse/t_const.h"
-#include "thrift/parse/t_field.h"
-
-#include "thrift/version.h"
-
-#include "thrift/audit/t_audit.h"
-
-extern int g_warn;
-extern std::string g_curpath;
-extern bool g_return_failure;
-
-void thrift_audit_warning(int level, const char* fmt, ...) {
-   if (g_warn < level) {
-      return;
-   }
-   va_list args;
-   printf("[Thrift Audit Warning:%s] ", g_curpath.c_str());
-   va_start(args, fmt);
-   vprintf(fmt, args);
-   va_end(args);
-   printf("\n");
-}
-
-void thrift_audit_failure(const char* fmt, ...) {
-  va_list args;
-  fprintf(stderr, "[Thrift Audit Failure:%s] ", g_curpath.c_str());
-  va_start(args, fmt);
-  vfprintf(stderr, fmt, args);
-  va_end(args);
-  fprintf(stderr, "\n");
-  g_return_failure = true;
-}
-
-void compare_namespace(t_program* newProgram, t_program* oldProgram)
-{
-   const std::map<std::string, std::string>& newNamespaceMap = newProgram->get_all_namespaces();
-   const std::map<std::string, std::string>& oldNamespaceMap = oldProgram->get_all_namespaces();
-
-   for(std::map<std::string, std::string>::const_iterator oldNamespaceMapIt = oldNamespaceMap.begin();
-         oldNamespaceMapIt != oldNamespaceMap.end();
-         oldNamespaceMapIt++)
-   {
-      std::map<std::string, std::string>::const_iterator newNamespaceMapIt = newNamespaceMap.find(oldNamespaceMapIt->first);
-      if(newNamespaceMapIt == newNamespaceMap.end())
-      {
-         thrift_audit_warning(1, "Language %s not found in new thrift file\n", (oldNamespaceMapIt->first).c_str());
-      }
-      else if((newNamespaceMapIt->second) != oldNamespaceMapIt->second)
-      {
-         thrift_audit_warning(1, "Namespace %s changed in new thrift file\n", (oldNamespaceMapIt->second).c_str());
-      }
-   }
-}
-
-void compare_enum_values(t_enum* newEnum,t_enum* oldEnum)
-{
-   const std::vector<t_enum_value*>& oldEnumValues = oldEnum->get_constants();
-   for(std::vector<t_enum_value*>::const_iterator oldEnumValuesIt = oldEnumValues.begin();
-         oldEnumValuesIt != oldEnumValues.end();
-         oldEnumValuesIt++)
-   {
-      int enumValue = (*oldEnumValuesIt)->get_value();
-      t_enum_value* newEnumValue = newEnum->get_constant_by_value(enumValue);
-      if(newEnumValue != NULL)
-      {
-         std::string enumName = (*oldEnumValuesIt)->get_name();
-         if(enumName != newEnumValue->get_name())
-         {
-            thrift_audit_warning(1, "Name of the value %d changed in enum %s\n", enumValue, oldEnum->get_name().c_str());
-         }
-      }
-      else
-      {
-         thrift_audit_failure("Enum value %d missing in %s\n", enumValue, oldEnum->get_name().c_str());
-      }
-
-   }
-}
-
-void compare_enums(const std::vector<t_enum*>& newEnumList, const std::vector<t_enum*>& oldEnumList)
-{
-   std::map<std::string,t_enum*> newEnumMap;
-   std::vector<t_enum*>::const_iterator newEnumIt;
-   for(newEnumIt = newEnumList.begin(); newEnumIt != newEnumList.end(); newEnumIt++)
-   {
-      newEnumMap[(*newEnumIt)->get_name()] = *newEnumIt;
-   }
-   std::vector<t_enum*>::const_iterator oldEnumIt;
-   for(oldEnumIt = oldEnumList.begin(); oldEnumIt != oldEnumList.end(); oldEnumIt++)
-   {
-      std::map<std::string,t_enum*>::iterator newEnumMapIt;
-      newEnumMapIt = newEnumMap.find((*oldEnumIt)->get_name());
-
-      if(newEnumMapIt == newEnumMap.end())
-      {
-         thrift_audit_warning(1, "Enum %s not found in new thrift file\n",(*oldEnumIt)->get_name().c_str());
-      }
-      else
-      {
-         compare_enum_values(newEnumMapIt->second, *oldEnumIt);
-      }
-   }
-}
-
-//This function returns 'true' if the two arguements are of same types.
-//Returns false if they are of different type
-bool compare_type(t_type* newType, t_type* oldType)
-{
-   //Comparing names of two types will work when the newType and oldType are basic types or structs or enums.
-   //However, when they are containers, get_name() returns empty for which we have to compare the type of
-   //their elements as well.
-   if((newType->get_name()).empty() && (oldType->get_name()).empty())
-   {
-
-      if(newType->is_list() && oldType->is_list())
-      {
-         t_type* newElementType = ((t_list*)newType)->get_elem_type();
-         t_type* oldElementType = ((t_list*)oldType)->get_elem_type();
-         return compare_type(newElementType, oldElementType);
-      }
-      else if(newType->is_map() && oldType->is_map())
-      {
-         t_type* newKeyType = ((t_map*)newType)->get_key_type();
-         t_type* oldKeyType = ((t_map*)oldType)->get_key_type();
-
-         t_type* newValType = ((t_map*)newType)->get_val_type();
-         t_type* oldValType = ((t_map*)oldType)->get_val_type();
-
-         return (compare_type(newKeyType, oldKeyType) && compare_type(newValType, oldValType));
-      }
-      else if(newType->is_set() && oldType->is_set())
-      {
-         t_type* newElementType = ((t_set*)newType)->get_elem_type();
-         t_type* oldElementType = ((t_set*)oldType)->get_elem_type();
-         return compare_type(newElementType, oldElementType);
-      }
-      else
-      {
-         return false;
-      }
-   }
-   else if(newType->get_name() == oldType->get_name())
-   {
-      return true;
-   }
-   else
-   {
-      return false;
-   }
-}
-
-bool compare_pair(std::pair<t_const_value*, t_const_value*> newMapPair, std::pair<t_const_value*, t_const_value*> oldMapPair)
-{
-   return compare_defaults(newMapPair.first, oldMapPair.first) && compare_defaults(newMapPair.second, oldMapPair.second);
-}
-
-// This function returns 'true' if the default values are same. Returns false if they are different.
-bool compare_defaults(t_const_value* newStructDefault, t_const_value* oldStructDefault)
-{
-   if(newStructDefault == NULL && oldStructDefault == NULL) return true;
-   else if(newStructDefault == NULL && oldStructDefault != NULL) return false;
-   else if (newStructDefault != NULL && oldStructDefault == NULL) return false;
-
-   if(newStructDefault->get_type() != oldStructDefault->get_type())
-   {
-      return false;
-   }
-
-   switch(newStructDefault->get_type())
-   {
-      case t_const_value::CV_INTEGER:
-         return (newStructDefault->get_integer() == oldStructDefault->get_integer());
-      case t_const_value::CV_DOUBLE:
-         return (newStructDefault->get_double() == oldStructDefault->get_double());
-      case t_const_value::CV_STRING:
-         return (newStructDefault->get_string() == oldStructDefault->get_string());
-      case t_const_value::CV_LIST:
-         {
-            const std::vector<t_const_value*>& oldDefaultList = oldStructDefault->get_list();
-            const std::vector<t_const_value*>& newDefaultList = newStructDefault->get_list();
-            bool defaultValuesCompare = (oldDefaultList.size() == newDefaultList.size());
-
-            return defaultValuesCompare && std::equal(newDefaultList.begin(), newDefaultList.end(), oldDefaultList.begin(), compare_defaults);
-         }
-      case t_const_value::CV_MAP:
-         {
-            const std::map<t_const_value*, t_const_value*, t_const_value::value_compare> newMap = newStructDefault->get_map();
-            const std::map<t_const_value*, t_const_value*, t_const_value::value_compare> oldMap = oldStructDefault->get_map();
-
-            bool defaultValuesCompare = (oldMap.size() == newMap.size());
-
-            return defaultValuesCompare && std::equal(newMap.begin(), newMap.end(), oldMap.begin(), compare_pair);
-         }
-      case t_const_value::CV_IDENTIFIER:
-         return (newStructDefault->get_identifier() == oldStructDefault->get_identifier());
-      default:
-         return false;
-   }
-
-}
-
-void compare_struct_field(t_field* newField, t_field* oldField, std::string oldStructName)
-{
-   t_type* newFieldType = newField->get_type();
-   t_type* oldFieldType = oldField->get_type();
-   if(!compare_type(newFieldType, oldFieldType))
-   {
-      thrift_audit_failure("Struct Field Type Changed for Id = %d in %s \n", newField->get_key(), oldStructName.c_str());
-   }
-
-   // A Struct member can be optional if it is mentioned explicitly, or if it is assigned with default values.
-   bool newStructFieldOptional = (newField->get_req() != t_field::T_REQUIRED);
-   bool oldStructFieldOptional = (oldField->get_req() != t_field::T_REQUIRED);
-
-   if(newStructFieldOptional != oldStructFieldOptional)
-   {
-      thrift_audit_failure("Struct Field Requiredness Changed for Id = %d in %s \n", newField->get_key(), oldStructName.c_str());
-   }
-   if(newStructFieldOptional || oldStructFieldOptional)
-   {
-      if(!compare_defaults(newField->get_value(), oldField->get_value()))
-      {
-         thrift_audit_warning(1, "Default value changed for Id = %d in %s \n", newField->get_key(), oldStructName.c_str());
-      }
-   }
-
-   std::string fieldName = newField->get_name();
-   if(fieldName != oldField->get_name())
-   {
-      thrift_audit_warning(1, "Struct field name changed for Id = %d in %s\n", newField->get_key(), oldStructName.c_str());
-   }
-
-}
-
-void compare_single_struct(t_struct* newStruct, t_struct* oldStruct, const std::string& oldStructName = std::string())
-{
-   std::string structName = oldStructName.empty() ? oldStruct->get_name() : oldStructName;
-   const std::vector<t_field*>& oldStructMembersInIdOrder = oldStruct->get_sorted_members();
-   const std::vector<t_field*>& newStructMembersInIdOrder = newStruct->get_sorted_members();
-   std::vector<t_field*>::const_iterator oldStructMemberIt = oldStructMembersInIdOrder.begin();
-   std::vector<t_field*>::const_iterator newStructMemberIt = newStructMembersInIdOrder.begin();
-
-   // Since we have the struct members in their ID order, comparing their IDs can be done by traversing the two member
-   // lists together.
-   while(!(oldStructMemberIt == oldStructMembersInIdOrder.end() && newStructMemberIt == newStructMembersInIdOrder.end()))
-   {
-      if(newStructMemberIt == newStructMembersInIdOrder.end() && oldStructMemberIt != oldStructMembersInIdOrder.end())
-      {
-         // A field ID has been removed from the end.
-         thrift_audit_failure("Struct Field removed for Id = %d in %s \n", (*oldStructMemberIt)->get_key(), structName.c_str());
-         oldStructMemberIt++;
-      }
-      else if(newStructMemberIt != newStructMembersInIdOrder.end() && oldStructMemberIt == oldStructMembersInIdOrder.end())
-      {
-         //New field ID has been added to the end.
-         if((*newStructMemberIt)->get_req() == t_field::T_REQUIRED)
-         {
-            thrift_audit_failure("Required Struct Field Added for Id = %d in %s \n", (*newStructMemberIt)->get_key(), structName.c_str());
-         }
-         newStructMemberIt++;
-      }
-      else if((*newStructMemberIt)->get_key() == (*oldStructMemberIt)->get_key())
-      {
-         //Field ID found in both structs. Compare field types, default values.
-         compare_struct_field(*newStructMemberIt, *oldStructMemberIt, structName);
-
-         newStructMemberIt++;
-         oldStructMemberIt++;
-      }
-      else if((*newStructMemberIt)->get_key() < (*oldStructMemberIt)->get_key())
-      {
-         //New Field Id is inserted in between
-         //Adding fields to struct is fine, but adding them in the middle is suspicious. Error!!
-         thrift_audit_failure("Struct field is added in the middle with Id = %d in %s\n",  (*newStructMemberIt)->get_key(),  structName.c_str());
-         newStructMemberIt++;
-      }
-      else if((*newStructMemberIt)->get_key() > (*oldStructMemberIt)->get_key())
-      {
-         //A field is deleted in newStruct.
-         thrift_audit_failure("Struct Field removed for Id = %d in %s \n",  (*oldStructMemberIt)->get_key(), structName.c_str());
-         oldStructMemberIt++;
-      }
-
-   }
-}
-
-void compare_structs(const std::vector<t_struct*>& newStructList, const std::vector<t_struct*>& oldStructList)
-{
-   std::map<std::string,t_struct*> newStructMap;
-   std::vector<t_struct*>::const_iterator newStructListIt;
-   for(newStructListIt = newStructList.begin(); newStructListIt != newStructList.end(); newStructListIt++)
-   {
-      newStructMap[(*newStructListIt)->get_name()] = *newStructListIt;
-   }
-
-   std::vector<t_struct*>::const_iterator oldStructListIt;
-   for(oldStructListIt = oldStructList.begin(); oldStructListIt != oldStructList.end(); oldStructListIt++)
-   {
-      std::map<std::string, t_struct*>::iterator newStructMapIt;
-      newStructMapIt = newStructMap.find((*oldStructListIt)->get_name());
-      if(newStructMapIt == newStructMap.end())
-      {
-         thrift_audit_failure("Struct %s not found in new thrift file\n", (*oldStructListIt)->get_name().c_str());
-      }
-      else
-      {
-         compare_single_struct(newStructMapIt->second, *oldStructListIt);
-      }
-   }
-
-}
-
-void compare_single_function(t_function* newFunction, t_function* oldFunction)
-{
-   t_type* newFunctionReturnType = newFunction->get_returntype();
-
-   if(newFunction->is_oneway() != oldFunction->is_oneway())
-   {
-      thrift_audit_failure("Oneway attribute changed for function %s\n",oldFunction->get_name().c_str());
-   }
-   if(!compare_type(newFunctionReturnType, oldFunction->get_returntype()))
-   {
-      thrift_audit_failure("Return type changed for function %s\n",oldFunction->get_name().c_str());
-   }
-
-   //Compare function arguments.
-   compare_single_struct(newFunction->get_arglist(), oldFunction->get_arglist());
-   std::string exceptionName = oldFunction->get_name();
-   exceptionName += "_exception";
-   compare_single_struct(newFunction->get_xceptions(), oldFunction->get_xceptions(), exceptionName);
-}
-
-void compare_functions(const std::vector<t_function*>& newFunctionList, const std::vector<t_function*>& oldFunctionList)
-{
-   std::map<std::string, t_function*> newFunctionMap;
-   std::map<std::string, t_function*>::iterator newFunctionMapIt;
-   for(std::vector<t_function*>::const_iterator newFunctionIt = newFunctionList.begin();
-         newFunctionIt != newFunctionList.end();
-         newFunctionIt++)
-   {
-      newFunctionMap[(*newFunctionIt)->get_name()] = *newFunctionIt;
-   }
-
-   for(std::vector<t_function*>::const_iterator oldFunctionIt = oldFunctionList.begin();
-         oldFunctionIt != oldFunctionList.end();
-         oldFunctionIt++)
-   {
-      newFunctionMapIt = newFunctionMap.find((*oldFunctionIt)->get_name());
-      if(newFunctionMapIt == newFunctionMap.end())
-      {
-         thrift_audit_failure("New Thrift File has missing function %s\n",(*oldFunctionIt)->get_name().c_str());
-         continue;
-      }
-      else
-      {
-         //Function is found in both thrift files. Compare return type and argument list
-         compare_single_function(newFunctionMapIt->second, *oldFunctionIt);
-      }
-   }
-
-}
-
-void compare_services(const std::vector<t_service*>& newServices, const std::vector<t_service*>& oldServices)
-{
-   std::vector<t_service*>::const_iterator oldServiceIt;
-
-   std::map<std::string, t_service*> newServiceMap;
-   for(std::vector<t_service*>::const_iterator newServiceIt = newServices.begin();
-         newServiceIt != newServices.end();
-         newServiceIt++)
-   {
-      newServiceMap[(*newServiceIt)->get_name()] = *newServiceIt;
-   }
-
-
-   for(oldServiceIt = oldServices.begin(); oldServiceIt != oldServices.end(); oldServiceIt++)
-   {
-      const std::string oldServiceName = (*oldServiceIt)->get_name();
-      std::map<std::string, t_service*>::iterator newServiceMapIt = newServiceMap.find(oldServiceName);
-
-      if(newServiceMapIt == newServiceMap.end())
-      {
-         thrift_audit_failure("New Thrift file is missing a service %s\n", oldServiceName.c_str());
-      }
-      else
-      {
-         t_service* oldServiceExtends = (*oldServiceIt)->get_extends();
-         t_service* newServiceExtends = (newServiceMapIt->second)->get_extends();
-
-         if(oldServiceExtends == NULL)
-         {
-            // It is fine to add extends. So if service in older thrift did not have any extends, we are fine.
-            // DO Nothing
-         }
-         else if(oldServiceExtends != NULL && newServiceExtends == NULL)
-         {
-            thrift_audit_failure("Change in Service inheritance for %s\n", oldServiceName.c_str());
-         }
-         else
-         {
-            std::string oldExtendsName = oldServiceExtends->get_name();
-            std::string newExtendsName = newServiceExtends->get_name();
-
-            if( newExtendsName != oldExtendsName)
-            {
-               thrift_audit_failure("Change in Service inheritance for %s\n", oldServiceName.c_str());
-            }
-         }
-
-         compare_functions((newServiceMapIt->second)->get_functions(), (*oldServiceIt)->get_functions());
-      }
-
-   }
-
-}
-
-void compare_consts(const std::vector<t_const*>& newConst, const std::vector<t_const*>& oldConst)
-{
-   std::vector<t_const*>::const_iterator newConstIt;
-   std::vector<t_const*>::const_iterator oldConstIt;
-
-   std::map<std::string, t_const*> newConstMap;
-
-   for(newConstIt = newConst.begin(); newConstIt != newConst.end(); newConstIt++)
-   {
-      newConstMap[(*newConstIt)->get_name()] = *newConstIt;
-   }
-
-   std::map<std::string, t_const*>::const_iterator newConstMapIt;
-   for(oldConstIt = oldConst.begin(); oldConstIt != oldConst.end(); oldConstIt++)
-   {
-      newConstMapIt = newConstMap.find((*oldConstIt)->get_name());
-      if(newConstMapIt == newConstMap.end())
-      {
-         thrift_audit_warning(1, "Constants Missing %s \n", ((*oldConstIt)->get_name()).c_str());
-      }
-      else if(!compare_type((newConstMapIt->second)->get_type(), (*oldConstIt)->get_type()))
-      {
-         thrift_audit_warning(1, "Constant %s is of different type \n", ((*oldConstIt)->get_name()).c_str());
-      }
-      else if(!compare_defaults((newConstMapIt->second)->get_value(), (*oldConstIt)->get_value()))
-      {
-         thrift_audit_warning(1, "Constant %s has different value\n", ((*oldConstIt)->get_name()).c_str());
-      }
-   }
-}
+ 
+#include <cassert> 
+#include <stdlib.h> 
+#include <stdio.h> 
+#include <stdarg.h> 
+#include <time.h> 
+#include <string> 
+#include <algorithm> 
+#include <sys/types.h> 
+#include <sys/stat.h> 
+#include <errno.h> 
+#include <limits.h> 
+ 
+// Careful: must include globals first for extern definitions 
+#include "thrift/globals.h" 
+ 
+#include "thrift/parse/t_program.h" 
+#include "thrift/parse/t_scope.h" 
+#include "thrift/parse/t_const.h" 
+#include "thrift/parse/t_field.h" 
+ 
+#include "thrift/version.h" 
+ 
+#include "thrift/audit/t_audit.h" 
+ 
+extern int g_warn; 
+extern std::string g_curpath; 
+extern bool g_return_failure; 
+ 
+void thrift_audit_warning(int level, const char* fmt, ...) { 
+   if (g_warn < level) { 
+      return; 
+   } 
+   va_list args; 
+   printf("[Thrift Audit Warning:%s] ", g_curpath.c_str()); 
+   va_start(args, fmt); 
+   vprintf(fmt, args); 
+   va_end(args); 
+   printf("\n"); 
+} 
+ 
+void thrift_audit_failure(const char* fmt, ...) { 
+  va_list args; 
+  fprintf(stderr, "[Thrift Audit Failure:%s] ", g_curpath.c_str()); 
+  va_start(args, fmt); 
+  vfprintf(stderr, fmt, args); 
+  va_end(args); 
+  fprintf(stderr, "\n"); 
+  g_return_failure = true; 
+} 
+ 
+void compare_namespace(t_program* newProgram, t_program* oldProgram) 
+{ 
+   const std::map<std::string, std::string>& newNamespaceMap = newProgram->get_all_namespaces(); 
+   const std::map<std::string, std::string>& oldNamespaceMap = oldProgram->get_all_namespaces(); 
+ 
+   for(std::map<std::string, std::string>::const_iterator oldNamespaceMapIt = oldNamespaceMap.begin(); 
+         oldNamespaceMapIt != oldNamespaceMap.end(); 
+         oldNamespaceMapIt++) 
+   { 
+      std::map<std::string, std::string>::const_iterator newNamespaceMapIt = newNamespaceMap.find(oldNamespaceMapIt->first); 
+      if(newNamespaceMapIt == newNamespaceMap.end()) 
+      { 
+         thrift_audit_warning(1, "Language %s not found in new thrift file\n", (oldNamespaceMapIt->first).c_str()); 
+      } 
+      else if((newNamespaceMapIt->second) != oldNamespaceMapIt->second) 
+      { 
+         thrift_audit_warning(1, "Namespace %s changed in new thrift file\n", (oldNamespaceMapIt->second).c_str()); 
+      } 
+   } 
+} 
+ 
+void compare_enum_values(t_enum* newEnum,t_enum* oldEnum) 
+{ 
+   const std::vector<t_enum_value*>& oldEnumValues = oldEnum->get_constants(); 
+   for(std::vector<t_enum_value*>::const_iterator oldEnumValuesIt = oldEnumValues.begin(); 
+         oldEnumValuesIt != oldEnumValues.end(); 
+         oldEnumValuesIt++) 
+   { 
+      int enumValue = (*oldEnumValuesIt)->get_value(); 
+      t_enum_value* newEnumValue = newEnum->get_constant_by_value(enumValue); 
+      if(newEnumValue != NULL) 
+      { 
+         std::string enumName = (*oldEnumValuesIt)->get_name(); 
+         if(enumName != newEnumValue->get_name()) 
+         { 
+            thrift_audit_warning(1, "Name of the value %d changed in enum %s\n", enumValue, oldEnum->get_name().c_str()); 
+         } 
+      } 
+      else 
+      { 
+         thrift_audit_failure("Enum value %d missing in %s\n", enumValue, oldEnum->get_name().c_str()); 
+      } 
+ 
+   } 
+} 
+ 
+void compare_enums(const std::vector<t_enum*>& newEnumList, const std::vector<t_enum*>& oldEnumList) 
+{ 
+   std::map<std::string,t_enum*> newEnumMap; 
+   std::vector<t_enum*>::const_iterator newEnumIt; 
+   for(newEnumIt = newEnumList.begin(); newEnumIt != newEnumList.end(); newEnumIt++) 
+   { 
+      newEnumMap[(*newEnumIt)->get_name()] = *newEnumIt; 
+   } 
+   std::vector<t_enum*>::const_iterator oldEnumIt; 
+   for(oldEnumIt = oldEnumList.begin(); oldEnumIt != oldEnumList.end(); oldEnumIt++) 
+   { 
+      std::map<std::string,t_enum*>::iterator newEnumMapIt; 
+      newEnumMapIt = newEnumMap.find((*oldEnumIt)->get_name()); 
+ 
+      if(newEnumMapIt == newEnumMap.end()) 
+      { 
+         thrift_audit_warning(1, "Enum %s not found in new thrift file\n",(*oldEnumIt)->get_name().c_str()); 
+      } 
+      else 
+      { 
+         compare_enum_values(newEnumMapIt->second, *oldEnumIt); 
+      } 
+   } 
+} 
+ 
+//This function returns 'true' if the two arguements are of same types. 
+//Returns false if they are of different type 
+bool compare_type(t_type* newType, t_type* oldType) 
+{ 
+   //Comparing names of two types will work when the newType and oldType are basic types or structs or enums. 
+   //However, when they are containers, get_name() returns empty for which we have to compare the type of 
+   //their elements as well. 
+   if((newType->get_name()).empty() && (oldType->get_name()).empty()) 
+   { 
+ 
+      if(newType->is_list() && oldType->is_list()) 
+      { 
+         t_type* newElementType = ((t_list*)newType)->get_elem_type(); 
+         t_type* oldElementType = ((t_list*)oldType)->get_elem_type(); 
+         return compare_type(newElementType, oldElementType); 
+      } 
+      else if(newType->is_map() && oldType->is_map()) 
+      { 
+         t_type* newKeyType = ((t_map*)newType)->get_key_type(); 
+         t_type* oldKeyType = ((t_map*)oldType)->get_key_type(); 
+ 
+         t_type* newValType = ((t_map*)newType)->get_val_type(); 
+         t_type* oldValType = ((t_map*)oldType)->get_val_type(); 
+ 
+         return (compare_type(newKeyType, oldKeyType) && compare_type(newValType, oldValType)); 
+      } 
+      else if(newType->is_set() && oldType->is_set()) 
+      { 
+         t_type* newElementType = ((t_set*)newType)->get_elem_type(); 
+         t_type* oldElementType = ((t_set*)oldType)->get_elem_type(); 
+         return compare_type(newElementType, oldElementType); 
+      } 
+      else 
+      { 
+         return false; 
+      } 
+   } 
+   else if(newType->get_name() == oldType->get_name()) 
+   { 
+      return true; 
+   } 
+   else 
+   { 
+      return false; 
+   } 
+} 
+ 
+bool compare_pair(std::pair<t_const_value*, t_const_value*> newMapPair, std::pair<t_const_value*, t_const_value*> oldMapPair) 
+{ 
+   return compare_defaults(newMapPair.first, oldMapPair.first) && compare_defaults(newMapPair.second, oldMapPair.second); 
+} 
+ 
+// This function returns 'true' if the default values are same. Returns false if they are different. 
+bool compare_defaults(t_const_value* newStructDefault, t_const_value* oldStructDefault) 
+{ 
+   if(newStructDefault == NULL && oldStructDefault == NULL) return true; 
+   else if(newStructDefault == NULL && oldStructDefault != NULL) return false; 
+   else if (newStructDefault != NULL && oldStructDefault == NULL) return false; 
+ 
+   if(newStructDefault->get_type() != oldStructDefault->get_type()) 
+   { 
+      return false; 
+   } 
+ 
+   switch(newStructDefault->get_type()) 
+   { 
+      case t_const_value::CV_INTEGER: 
+         return (newStructDefault->get_integer() == oldStructDefault->get_integer()); 
+      case t_const_value::CV_DOUBLE: 
+         return (newStructDefault->get_double() == oldStructDefault->get_double()); 
+      case t_const_value::CV_STRING: 
+         return (newStructDefault->get_string() == oldStructDefault->get_string()); 
+      case t_const_value::CV_LIST: 
+         { 
+            const std::vector<t_const_value*>& oldDefaultList = oldStructDefault->get_list(); 
+            const std::vector<t_const_value*>& newDefaultList = newStructDefault->get_list(); 
+            bool defaultValuesCompare = (oldDefaultList.size() == newDefaultList.size()); 
+ 
+            return defaultValuesCompare && std::equal(newDefaultList.begin(), newDefaultList.end(), oldDefaultList.begin(), compare_defaults); 
+         } 
+      case t_const_value::CV_MAP: 
+         { 
+            const std::map<t_const_value*, t_const_value*, t_const_value::value_compare> newMap = newStructDefault->get_map(); 
+            const std::map<t_const_value*, t_const_value*, t_const_value::value_compare> oldMap = oldStructDefault->get_map(); 
+ 
+            bool defaultValuesCompare = (oldMap.size() == newMap.size()); 
+ 
+            return defaultValuesCompare && std::equal(newMap.begin(), newMap.end(), oldMap.begin(), compare_pair); 
+         } 
+      case t_const_value::CV_IDENTIFIER: 
+         return (newStructDefault->get_identifier() == oldStructDefault->get_identifier()); 
+      default: 
+         return false; 
+   } 
+ 
+} 
+ 
+void compare_struct_field(t_field* newField, t_field* oldField, std::string oldStructName) 
+{ 
+   t_type* newFieldType = newField->get_type(); 
+   t_type* oldFieldType = oldField->get_type(); 
+   if(!compare_type(newFieldType, oldFieldType)) 
+   { 
+      thrift_audit_failure("Struct Field Type Changed for Id = %d in %s \n", newField->get_key(), oldStructName.c_str()); 
+   } 
+ 
+   // A Struct member can be optional if it is mentioned explicitly, or if it is assigned with default values. 
+   bool newStructFieldOptional = (newField->get_req() != t_field::T_REQUIRED); 
+   bool oldStructFieldOptional = (oldField->get_req() != t_field::T_REQUIRED); 
+ 
+   if(newStructFieldOptional != oldStructFieldOptional) 
+   { 
+      thrift_audit_failure("Struct Field Requiredness Changed for Id = %d in %s \n", newField->get_key(), oldStructName.c_str()); 
+   } 
+   if(newStructFieldOptional || oldStructFieldOptional) 
+   { 
+      if(!compare_defaults(newField->get_value(), oldField->get_value())) 
+      { 
+         thrift_audit_warning(1, "Default value changed for Id = %d in %s \n", newField->get_key(), oldStructName.c_str()); 
+      } 
+   } 
+ 
+   std::string fieldName = newField->get_name(); 
+   if(fieldName != oldField->get_name()) 
+   { 
+      thrift_audit_warning(1, "Struct field name changed for Id = %d in %s\n", newField->get_key(), oldStructName.c_str()); 
+   } 
+ 
+} 
+ 
+void compare_single_struct(t_struct* newStruct, t_struct* oldStruct, const std::string& oldStructName = std::string()) 
+{ 
+   std::string structName = oldStructName.empty() ? oldStruct->get_name() : oldStructName; 
+   const std::vector<t_field*>& oldStructMembersInIdOrder = oldStruct->get_sorted_members(); 
+   const std::vector<t_field*>& newStructMembersInIdOrder = newStruct->get_sorted_members(); 
+   std::vector<t_field*>::const_iterator oldStructMemberIt = oldStructMembersInIdOrder.begin(); 
+   std::vector<t_field*>::const_iterator newStructMemberIt = newStructMembersInIdOrder.begin(); 
+ 
+   // Since we have the struct members in their ID order, comparing their IDs can be done by traversing the two member 
+   // lists together. 
+   while(!(oldStructMemberIt == oldStructMembersInIdOrder.end() && newStructMemberIt == newStructMembersInIdOrder.end())) 
+   { 
+      if(newStructMemberIt == newStructMembersInIdOrder.end() && oldStructMemberIt != oldStructMembersInIdOrder.end()) 
+      { 
+         // A field ID has been removed from the end. 
+         thrift_audit_failure("Struct Field removed for Id = %d in %s \n", (*oldStructMemberIt)->get_key(), structName.c_str()); 
+         oldStructMemberIt++; 
+      } 
+      else if(newStructMemberIt != newStructMembersInIdOrder.end() && oldStructMemberIt == oldStructMembersInIdOrder.end()) 
+      { 
+         //New field ID has been added to the end. 
+         if((*newStructMemberIt)->get_req() == t_field::T_REQUIRED) 
+         { 
+            thrift_audit_failure("Required Struct Field Added for Id = %d in %s \n", (*newStructMemberIt)->get_key(), structName.c_str()); 
+         } 
+         newStructMemberIt++; 
+      } 
+      else if((*newStructMemberIt)->get_key() == (*oldStructMemberIt)->get_key()) 
+      { 
+         //Field ID found in both structs. Compare field types, default values. 
+         compare_struct_field(*newStructMemberIt, *oldStructMemberIt, structName); 
+ 
+         newStructMemberIt++; 
+         oldStructMemberIt++; 
+      } 
+      else if((*newStructMemberIt)->get_key() < (*oldStructMemberIt)->get_key()) 
+      { 
+         //New Field Id is inserted in between 
+         //Adding fields to struct is fine, but adding them in the middle is suspicious. Error!! 
+         thrift_audit_failure("Struct field is added in the middle with Id = %d in %s\n",  (*newStructMemberIt)->get_key(),  structName.c_str()); 
+         newStructMemberIt++; 
+      } 
+      else if((*newStructMemberIt)->get_key() > (*oldStructMemberIt)->get_key()) 
+      { 
+         //A field is deleted in newStruct. 
+         thrift_audit_failure("Struct Field removed for Id = %d in %s \n",  (*oldStructMemberIt)->get_key(), structName.c_str()); 
+         oldStructMemberIt++; 
+      } 
+ 
+   } 
+} 
+ 
+void compare_structs(const std::vector<t_struct*>& newStructList, const std::vector<t_struct*>& oldStructList) 
+{ 
+   std::map<std::string,t_struct*> newStructMap; 
+   std::vector<t_struct*>::const_iterator newStructListIt; 
+   for(newStructListIt = newStructList.begin(); newStructListIt != newStructList.end(); newStructListIt++) 
+   { 
+      newStructMap[(*newStructListIt)->get_name()] = *newStructListIt; 
+   } 
+ 
+   std::vector<t_struct*>::const_iterator oldStructListIt; 
+   for(oldStructListIt = oldStructList.begin(); oldStructListIt != oldStructList.end(); oldStructListIt++) 
+   { 
+      std::map<std::string, t_struct*>::iterator newStructMapIt; 
+      newStructMapIt = newStructMap.find((*oldStructListIt)->get_name()); 
+      if(newStructMapIt == newStructMap.end()) 
+      { 
+         thrift_audit_failure("Struct %s not found in new thrift file\n", (*oldStructListIt)->get_name().c_str()); 
+      } 
+      else 
+      { 
+         compare_single_struct(newStructMapIt->second, *oldStructListIt); 
+      } 
+   } 
+ 
+} 
+ 
+void compare_single_function(t_function* newFunction, t_function* oldFunction) 
+{ 
+   t_type* newFunctionReturnType = newFunction->get_returntype(); 
+ 
+   if(newFunction->is_oneway() != oldFunction->is_oneway()) 
+   { 
+      thrift_audit_failure("Oneway attribute changed for function %s\n",oldFunction->get_name().c_str()); 
+   } 
+   if(!compare_type(newFunctionReturnType, oldFunction->get_returntype())) 
+   { 
+      thrift_audit_failure("Return type changed for function %s\n",oldFunction->get_name().c_str()); 
+   } 
+ 
+   //Compare function arguments. 
+   compare_single_struct(newFunction->get_arglist(), oldFunction->get_arglist()); 
+   std::string exceptionName = oldFunction->get_name(); 
+   exceptionName += "_exception"; 
+   compare_single_struct(newFunction->get_xceptions(), oldFunction->get_xceptions(), exceptionName); 
+} 
+ 
+void compare_functions(const std::vector<t_function*>& newFunctionList, const std::vector<t_function*>& oldFunctionList) 
+{ 
+   std::map<std::string, t_function*> newFunctionMap; 
+   std::map<std::string, t_function*>::iterator newFunctionMapIt; 
+   for(std::vector<t_function*>::const_iterator newFunctionIt = newFunctionList.begin(); 
+         newFunctionIt != newFunctionList.end(); 
+         newFunctionIt++) 
+   { 
+      newFunctionMap[(*newFunctionIt)->get_name()] = *newFunctionIt; 
+   } 
+ 
+   for(std::vector<t_function*>::const_iterator oldFunctionIt = oldFunctionList.begin(); 
+         oldFunctionIt != oldFunctionList.end(); 
+         oldFunctionIt++) 
+   { 
+      newFunctionMapIt = newFunctionMap.find((*oldFunctionIt)->get_name()); 
+      if(newFunctionMapIt == newFunctionMap.end()) 
+      { 
+         thrift_audit_failure("New Thrift File has missing function %s\n",(*oldFunctionIt)->get_name().c_str()); 
+         continue; 
+      } 
+      else 
+      { 
+         //Function is found in both thrift files. Compare return type and argument list 
+         compare_single_function(newFunctionMapIt->second, *oldFunctionIt); 
+      } 
+   } 
+ 
+} 
+ 
+void compare_services(const std::vector<t_service*>& newServices, const std::vector<t_service*>& oldServices) 
+{ 
+   std::vector<t_service*>::const_iterator oldServiceIt; 
+ 
+   std::map<std::string, t_service*> newServiceMap; 
+   for(std::vector<t_service*>::const_iterator newServiceIt = newServices.begin(); 
+         newServiceIt != newServices.end(); 
+         newServiceIt++) 
+   { 
+      newServiceMap[(*newServiceIt)->get_name()] = *newServiceIt; 
+   } 
+ 
+ 
+   for(oldServiceIt = oldServices.begin(); oldServiceIt != oldServices.end(); oldServiceIt++) 
+   { 
+      const std::string oldServiceName = (*oldServiceIt)->get_name(); 
+      std::map<std::string, t_service*>::iterator newServiceMapIt = newServiceMap.find(oldServiceName); 
+ 
+      if(newServiceMapIt == newServiceMap.end()) 
+      { 
+         thrift_audit_failure("New Thrift file is missing a service %s\n", oldServiceName.c_str()); 
+      } 
+      else 
+      { 
+         t_service* oldServiceExtends = (*oldServiceIt)->get_extends(); 
+         t_service* newServiceExtends = (newServiceMapIt->second)->get_extends(); 
+ 
+         if(oldServiceExtends == NULL) 
+         { 
+            // It is fine to add extends. So if service in older thrift did not have any extends, we are fine. 
+            // DO Nothing 
+         } 
+         else if(oldServiceExtends != NULL && newServiceExtends == NULL) 
+         { 
+            thrift_audit_failure("Change in Service inheritance for %s\n", oldServiceName.c_str()); 
+         } 
+         else 
+         { 
+            std::string oldExtendsName = oldServiceExtends->get_name(); 
+            std::string newExtendsName = newServiceExtends->get_name(); 
+ 
+            if( newExtendsName != oldExtendsName) 
+            { 
+               thrift_audit_failure("Change in Service inheritance for %s\n", oldServiceName.c_str()); 
+            } 
+         } 
+ 
+         compare_functions((newServiceMapIt->second)->get_functions(), (*oldServiceIt)->get_functions()); 
+      } 
+ 
+   } 
+ 
+} 
+ 
+void compare_consts(const std::vector<t_const*>& newConst, const std::vector<t_const*>& oldConst) 
+{ 
+   std::vector<t_const*>::const_iterator newConstIt; 
+   std::vector<t_const*>::const_iterator oldConstIt; 
+ 
+   std::map<std::string, t_const*> newConstMap; 
+ 
+   for(newConstIt = newConst.begin(); newConstIt != newConst.end(); newConstIt++) 
+   { 
+      newConstMap[(*newConstIt)->get_name()] = *newConstIt; 
+   } 
+ 
+   std::map<std::string, t_const*>::const_iterator newConstMapIt; 
+   for(oldConstIt = oldConst.begin(); oldConstIt != oldConst.end(); oldConstIt++) 
+   { 
+      newConstMapIt = newConstMap.find((*oldConstIt)->get_name()); 
+      if(newConstMapIt == newConstMap.end()) 
+      { 
+         thrift_audit_warning(1, "Constants Missing %s \n", ((*oldConstIt)->get_name()).c_str()); 
+      } 
+      else if(!compare_type((newConstMapIt->second)->get_type(), (*oldConstIt)->get_type())) 
+      { 
+         thrift_audit_warning(1, "Constant %s is of different type \n", ((*oldConstIt)->get_name()).c_str()); 
+      } 
+      else if(!compare_defaults((newConstMapIt->second)->get_value(), (*oldConstIt)->get_value())) 
+      { 
+         thrift_audit_warning(1, "Constant %s has different value\n", ((*oldConstIt)->get_name()).c_str()); 
+      } 
+   } 
+} 

contrib/restricted/thrift/compiler/thrift/audit/t_audit.h

@@ -1,14 +1,14 @@
-#ifndef T_AUDIT_H
-#define T_AUDIT_H
-
-void compare_namespace(t_program* newProgram, t_program* oldProgram);
-void compare_enums(const std::vector<t_enum*>& newEnumList,
-                   const std::vector<t_enum*>& oldEnumList);
-bool compare_defaults(t_const_value* newStructDefault, t_const_value* oldStructDefault);
-void compare_structs(const std::vector<t_struct*>& newStructList,
-                     const std::vector<t_struct*>& oldStructList);
-void compare_services(const std::vector<t_service*>& newServices,
-                      const std::vector<t_service*>& oldServices);
-void compare_consts(const std::vector<t_const*>& newConst, const std::vector<t_const*>& oldConst);
-
-#endif
+#ifndef T_AUDIT_H 
+#define T_AUDIT_H 
+ 
+void compare_namespace(t_program* newProgram, t_program* oldProgram); 
+void compare_enums(const std::vector<t_enum*>& newEnumList, 
+                   const std::vector<t_enum*>& oldEnumList); 
+bool compare_defaults(t_const_value* newStructDefault, t_const_value* oldStructDefault); 
+void compare_structs(const std::vector<t_struct*>& newStructList, 
+                     const std::vector<t_struct*>& oldStructList); 
+void compare_services(const std::vector<t_service*>& newServices, 
+                      const std::vector<t_service*>& oldServices); 
+void compare_consts(const std::vector<t_const*>& newConst, const std::vector<t_const*>& oldConst); 
+ 
+#endif 

contrib/restricted/thrift/compiler/thrift/common.cc

@@ -1,69 +1,69 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include "thrift/common.h"
-#include "thrift/parse/t_base_type.h"
-
-t_type* g_type_void;
-t_type* g_type_string;
-t_type* g_type_binary;
-t_type* g_type_slist;
-t_type* g_type_bool;
-t_type* g_type_i8;
-t_type* g_type_i16;
-t_type* g_type_i32;
-t_type* g_type_i64;
-t_type* g_type_double;
-
-void initGlobals() {
-  g_type_void = new t_base_type("void", t_base_type::TYPE_VOID);
-  g_type_string = new t_base_type("string", t_base_type::TYPE_STRING);
-  g_type_binary = new t_base_type("string", t_base_type::TYPE_STRING);
-  ((t_base_type*)g_type_binary)->set_binary(true);
-  g_type_slist = new t_base_type("string", t_base_type::TYPE_STRING);
-  ((t_base_type*)g_type_slist)->set_string_list(true);
-  g_type_bool = new t_base_type("bool", t_base_type::TYPE_BOOL);
-  g_type_i8 = new t_base_type("i8", t_base_type::TYPE_I8);
-  g_type_i16 = new t_base_type("i16", t_base_type::TYPE_I16);
-  g_type_i32 = new t_base_type("i32", t_base_type::TYPE_I32);
-  g_type_i64 = new t_base_type("i64", t_base_type::TYPE_I64);
-  g_type_double = new t_base_type("double", t_base_type::TYPE_DOUBLE);
-}
-
-void clearGlobals() {
-  delete g_type_void;
-  delete g_type_string;
-  delete g_type_bool;
-  delete g_type_i8;
-  delete g_type_i16;
-  delete g_type_i32;
-  delete g_type_i64;
-  delete g_type_double;
-}
-
-/**
- * Those are not really needed for plugins but causes link errors without
- */
-
-/**
- * The location of the last parsed doctext comment.
- */
-int g_doctext_lineno;
-int g_program_doctext_lineno = 0;
-PROGDOCTEXT_STATUS g_program_doctext_status = INVALID;
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one 
+ * or more contributor license agreements. See the NOTICE file 
+ * distributed with this work for additional information 
+ * regarding copyright ownership. The ASF licenses this file 
+ * to you under the Apache License, Version 2.0 (the 
+ * "License"); you may not use this file except in compliance 
+ * with the License. You may obtain a copy of the License at 
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, 
+ * software distributed under the License is distributed on an 
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
+ * KIND, either express or implied. See the License for the 
+ * specific language governing permissions and limitations 
+ * under the License. 
+ */ 
+ 
+#include "thrift/common.h" 
+#include "thrift/parse/t_base_type.h" 
+ 
+t_type* g_type_void; 
+t_type* g_type_string; 
+t_type* g_type_binary; 
+t_type* g_type_slist; 
+t_type* g_type_bool; 
+t_type* g_type_i8; 
+t_type* g_type_i16; 
+t_type* g_type_i32; 
+t_type* g_type_i64; 
+t_type* g_type_double; 
+ 
+void initGlobals() { 
+  g_type_void = new t_base_type("void", t_base_type::TYPE_VOID); 
+  g_type_string = new t_base_type("string", t_base_type::TYPE_STRING); 
+  g_type_binary = new t_base_type("string", t_base_type::TYPE_STRING); 
+  ((t_base_type*)g_type_binary)->set_binary(true); 
+  g_type_slist = new t_base_type("string", t_base_type::TYPE_STRING); 
+  ((t_base_type*)g_type_slist)->set_string_list(true); 
+  g_type_bool = new t_base_type("bool", t_base_type::TYPE_BOOL); 
+  g_type_i8 = new t_base_type("i8", t_base_type::TYPE_I8); 
+  g_type_i16 = new t_base_type("i16", t_base_type::TYPE_I16); 
+  g_type_i32 = new t_base_type("i32", t_base_type::TYPE_I32); 
+  g_type_i64 = new t_base_type("i64", t_base_type::TYPE_I64); 
+  g_type_double = new t_base_type("double", t_base_type::TYPE_DOUBLE); 
+} 
+ 
+void clearGlobals() { 
+  delete g_type_void; 
+  delete g_type_string; 
+  delete g_type_bool; 
+  delete g_type_i8; 
+  delete g_type_i16; 
+  delete g_type_i32; 
+  delete g_type_i64; 
+  delete g_type_double; 
+} 
+ 
+/** 
+ * Those are not really needed for plugins but causes link errors without 
+ */ 
+ 
+/** 
+ * The location of the last parsed doctext comment. 
+ */ 
+int g_doctext_lineno; 
+int g_program_doctext_lineno = 0; 
+PROGDOCTEXT_STATUS g_program_doctext_status = INVALID; 

contrib/restricted/thrift/compiler/thrift/common.h

@@ -1,43 +1,43 @@
-/*
- * 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 T_COMMON_H
-#define T_COMMON_H
-
-#include "thrift/parse/t_type.h"
-
-/**
- * Global types for the parser to be able to reference
- */
-
-extern t_type* g_type_void;
-extern t_type* g_type_string;
-extern t_type* g_type_binary;
-extern t_type* g_type_slist;
-extern t_type* g_type_bool;
-extern t_type* g_type_i8;
-extern t_type* g_type_i16;
-extern t_type* g_type_i32;
-extern t_type* g_type_i64;
-extern t_type* g_type_double;
-
-void initGlobals();
-void clearGlobals();
-
-#endif
+/* 
+ * 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 T_COMMON_H 
+#define T_COMMON_H 
+ 
+#include "thrift/parse/t_type.h" 
+ 
+/** 
+ * Global types for the parser to be able to reference 
+ */ 
+ 
+extern t_type* g_type_void; 
+extern t_type* g_type_string; 
+extern t_type* g_type_binary; 
+extern t_type* g_type_slist; 
+extern t_type* g_type_bool; 
+extern t_type* g_type_i8; 
+extern t_type* g_type_i16; 
+extern t_type* g_type_i32; 
+extern t_type* g_type_i64; 
+extern t_type* g_type_double; 
+ 
+void initGlobals(); 
+void clearGlobals(); 
+ 
+#endif 

contrib/restricted/thrift/compiler/thrift/generate/t_as3_generator.cc

@@ -1,2594 +1,2594 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <sstream>
-#include <string>
-#include <fstream>
-#include <iostream>
-#include <vector>
-#include <cctype>
-
-#include <sys/stat.h>
-#include <stdexcept>
-
-#include "thrift/platform.h"
-#include "thrift/generate/t_oop_generator.h"
-
-using std::map;
-using std::ostream;
-using std::ostringstream;
-using std::string;
-using std::stringstream;
-using std::vector;
-
-static const string endl = "\n"; // avoid ostream << std::endl flushes
-
-/**
- * AS3 code generator.
- *
- */
-class t_as3_generator : public t_oop_generator {
-public:
-  t_as3_generator(t_program* program,
-                  const std::map<std::string, std::string>& parsed_options,
-                  const std::string& option_string)
-    : t_oop_generator(program) {
-    (void)option_string;
-    std::map<std::string, std::string>::const_iterator iter;
-
-    bindable_ = false;
-    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
-      if( iter->first.compare("bindable") == 0) {
-        bindable_ = true;
-      } else {
-        throw "unknown option as3:" + iter->first;
-      }
-    }
-
-    out_dir_base_ = "gen-as3";
-  }
-
-  /**
-   * Init and close methods
-   */
-
-  void init_generator();
-  void close_generator();
-
-  void generate_consts(std::vector<t_const*> consts);
-
-  /**
-   * Program-level generation functions
-   */
-
-  void generate_typedef(t_typedef* ttypedef);
-  void generate_enum(t_enum* tenum);
-  void generate_struct(t_struct* tstruct);
-  void generate_xception(t_struct* txception);
-  void generate_service(t_service* tservice);
-
-  void print_const_value(std::ostream& out,
-                         std::string name,
-                         t_type* type,
-                         t_const_value* value,
-                         bool in_static,
-                         bool defval = false);
-  std::string render_const_value(ostream& out,
-                                 std::string name,
-                                 t_type* type,
-                                 t_const_value* value);
-
-  /**
-   * Service-level generation functions
-   */
-
-  void generate_as3_struct(t_struct* tstruct, bool is_exception);
-
-  void generate_as3_struct_definition(std::ostream& out,
-                                      t_struct* tstruct,
-                                      bool is_xception = false,
-                                      bool in_class = false,
-                                      bool is_result = false);
-  // removed -- equality,compare_to
-  void generate_as3_struct_reader(std::ostream& out, t_struct* tstruct);
-  void generate_as3_validator(std::ostream& out, t_struct* tstruct);
-  void generate_as3_struct_result_writer(std::ostream& out, t_struct* tstruct);
-  void generate_as3_struct_writer(std::ostream& out, t_struct* tstruct);
-  void generate_as3_struct_tostring(std::ostream& out, t_struct* tstruct, bool bindable);
-  void generate_as3_meta_data_map(std::ostream& out, t_struct* tstruct);
-  void generate_field_value_meta_data(std::ostream& out, t_type* type);
-  std::string get_as3_type_string(t_type* type);
-  void generate_reflection_setters(std::ostringstream& out,
-                                   t_type* type,
-                                   std::string field_name,
-                                   std::string cap_name);
-  void generate_reflection_getters(std::ostringstream& out,
-                                   t_type* type,
-                                   std::string field_name,
-                                   std::string cap_name);
-  void generate_generic_field_getters_setters(std::ostream& out, t_struct* tstruct);
-  void generate_generic_isset_method(std::ostream& out, t_struct* tstruct);
-  void generate_as3_bean_boilerplate(std::ostream& out, t_struct* tstruct, bool bindable);
-
-  void generate_function_helpers(t_function* tfunction);
-  std::string get_cap_name(std::string name);
-  std::string generate_isset_check(t_field* field);
-  std::string generate_isset_check(std::string field);
-  void generate_isset_set(ostream& out, t_field* field);
-  // removed std::string isset_field_id(t_field* field);
-
-  void generate_service_interface(t_service* tservice);
-  void generate_service_helpers(t_service* tservice);
-  void generate_service_client(t_service* tservice);
-  void generate_service_server(t_service* tservice);
-  void generate_process_function(t_service* tservice, t_function* tfunction);
-
-  /**
-   * Serialization constructs
-   */
-
-  void generate_deserialize_field(std::ostream& out, t_field* tfield, std::string prefix = "");
-
-  void generate_deserialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = "");
-
-  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-
-  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = "");
-
-  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = "");
-
-  void generate_deserialize_list_element(std::ostream& out,
-                                         t_list* tlist,
-                                         std::string prefix = "");
-
-  void generate_serialize_field(std::ostream& out, t_field* tfield, std::string prefix = "");
-
-  void generate_serialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = "");
-
-  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-
-  void generate_serialize_map_element(std::ostream& out,
-                                      t_map* tmap,
-                                      std::string iter,
-                                      std::string map);
-
-  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter);
-
-  void generate_serialize_list_element(std::ostream& out, t_list* tlist, std::string iter);
-
-  void generate_as3_doc(std::ostream& out, t_doc* tdoc);
-
-  void generate_as3_doc(std::ostream& out, t_function* tdoc);
-
-  /**
-   * Helper rendering functions
-   */
-
-  std::string as3_package();
-  std::string as3_type_imports();
-  std::string as3_thrift_imports();
-  std::string as3_thrift_gen_imports(t_struct* tstruct, string& imports);
-  std::string as3_thrift_gen_imports(t_service* tservice);
-  std::string type_name(t_type* ttype, bool in_container = false, bool in_init = false);
-  std::string base_type_name(t_base_type* tbase, bool in_container = false);
-  std::string declare_field(t_field* tfield, bool init = false);
-  std::string function_signature(t_function* tfunction, std::string prefix = "");
-  std::string argument_list(t_struct* tstruct);
-  std::string type_to_enum(t_type* ttype);
-  std::string get_enum_class_name(t_type* type);
-
-  bool type_can_be_null(t_type* ttype) {
-    ttype = get_true_type(ttype);
-
-    return ttype->is_container() || ttype->is_struct() || ttype->is_xception()
-           || ttype->is_string();
-  }
-
-  std::string constant_name(std::string name);
-
-private:
-  /**
-   * File streams
-   */
-
-  std::string package_name_;
-  ofstream_with_content_based_conditional_update f_service_;
-  std::string package_dir_;
-
-  bool bindable_;
-};
-
-/**
- * Prepares for file generation by opening up the necessary file output
- * streams.
- *
- * @param tprogram The program to generate
- */
-void t_as3_generator::init_generator() {
-  // Make output directory
-  MKDIR(get_out_dir().c_str());
-  package_name_ = program_->get_namespace("as3");
-
-  string dir = package_name_;
-  string subdir = get_out_dir();
-  string::size_type loc;
-  while ((loc = dir.find(".")) != string::npos) {
-    subdir = subdir + "/" + dir.substr(0, loc);
-    MKDIR(subdir.c_str());
-    dir = dir.substr(loc + 1);
-  }
-  if (dir.size() > 0) {
-    subdir = subdir + "/" + dir;
-    MKDIR(subdir.c_str());
-  }
-
-  package_dir_ = subdir;
-}
-
-/**
- * Packages the generated file
- *
- * @return String of the package, i.e. "package org.apache.thriftdemo;"
- */
-string t_as3_generator::as3_package() {
-  if (!package_name_.empty()) {
-    return string("package ") + package_name_ + " ";
-  }
-  return "package ";
-}
-
-/**
- * Prints standard as3 imports
- *
- * @return List of imports for As3 types that are used in here
- */
-string t_as3_generator::as3_type_imports() {
-  return string() + "import org.apache.thrift.Set;\n" + "import flash.utils.ByteArray;\n"
-         + "import flash.utils.Dictionary;\n\n";
-}
-
-/**
- * Prints standard as3 imports
- *
- * @return List of imports necessary for thrift
- */
-string t_as3_generator::as3_thrift_imports() {
-  return string() + "import org.apache.thrift.*;\n" + "import org.apache.thrift.meta_data.*;\n"
-         + "import org.apache.thrift.protocol.*;\n\n";
-}
-
-/**
- * Prints imports needed for a given type
- *
- * @return List of imports necessary for a given t_struct
- */
-string t_as3_generator::as3_thrift_gen_imports(t_struct* tstruct, string& imports) {
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  // For each type check if it is from a differnet namespace
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_program* program = (*m_iter)->get_type()->get_program();
-    if (program != NULL && program != program_) {
-      string package = program->get_namespace("as3");
-      if (!package.empty()) {
-        if (imports.find(package + "." + (*m_iter)->get_type()->get_name()) == string::npos) {
-          imports.append("import " + package + "." + (*m_iter)->get_type()->get_name() + ";\n");
-        }
-      }
-    }
-  }
-  return imports;
-}
-
-/**
- * Prints imports needed for a given type
- *
- * @return List of imports necessary for a given t_service
- */
-string t_as3_generator::as3_thrift_gen_imports(t_service* tservice) {
-  string imports;
-  const vector<t_function*>& functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-
-  // For each type check if it is from a differnet namespace
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    t_program* program = (*f_iter)->get_returntype()->get_program();
-    if (program != NULL && program != program_) {
-      string package = program->get_namespace("as3");
-      if (!package.empty()) {
-        if (imports.find(package + "." + (*f_iter)->get_returntype()->get_name()) == string::npos) {
-          imports.append("import " + package + "." + (*f_iter)->get_returntype()->get_name()
-                         + ";\n");
-        }
-      }
-    }
-
-    as3_thrift_gen_imports((*f_iter)->get_arglist(), imports);
-    as3_thrift_gen_imports((*f_iter)->get_xceptions(), imports);
-  }
-
-  return imports;
-}
-
-/**
- * Nothing in As3
- */
-void t_as3_generator::close_generator() {
-}
-
-/**
- * Generates a typedef. This is not done in As3, since it does
- * not support arbitrary name replacements, and it'd be a wacky waste
- * of overhead to make wrapper classes.
- *
- * @param ttypedef The type definition
- */
-void t_as3_generator::generate_typedef(t_typedef* ttypedef) {
-  (void)ttypedef;
-}
-
-/**
- * Enums are a class with a set of static constants.
- *
- * @param tenum The enumeration
- */
-void t_as3_generator::generate_enum(t_enum* tenum) {
-  // Make output file
-  string f_enum_name = package_dir_ + "/" + (tenum->get_name()) + ".as";
-  ofstream_with_content_based_conditional_update f_enum;
-  f_enum.open(f_enum_name);
-
-  // Comment and package it
-  f_enum << autogen_comment() << as3_package() << endl;
-
-  scope_up(f_enum);
-  // Add as3 imports
-  f_enum << string() + "import org.apache.thrift.Set;" << endl << "import flash.utils.Dictionary;"
-         << endl;
-
-  indent(f_enum) << "public class " << tenum->get_name() << " ";
-  scope_up(f_enum);
-
-  vector<t_enum_value*> constants = tenum->get_constants();
-  vector<t_enum_value*>::iterator c_iter;
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    int value = (*c_iter)->get_value();
-    indent(f_enum) << "public static const " << (*c_iter)->get_name() << ":int = " << value << ";"
-                   << endl;
-  }
-
-  // Create a static Set with all valid values for this enum
-  f_enum << endl;
-
-  indent(f_enum) << "public static const VALID_VALUES:Set = new Set(";
-  indent_up();
-  bool firstValue = true;
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    // populate set
-    f_enum << (firstValue ? "" : ", ") << (*c_iter)->get_name();
-    firstValue = false;
-  }
-  indent_down();
-  f_enum << ");" << endl;
-
-  indent(f_enum) << "public static const VALUES_TO_NAMES:Dictionary = new Dictionary();" << endl;
-
-  scope_up(f_enum);
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    indent(f_enum) << "VALUES_TO_NAMES[" << (*c_iter)->get_name() << "] = \""
-                   << (*c_iter)->get_name() << "\";" << endl;
-  }
-  f_enum << endl;
-
-  scope_down(f_enum);
-
-  scope_down(f_enum); // end class
-
-  scope_down(f_enum); // end package
-
-  f_enum.close();
-}
-
-/**
- * Generates a class that holds all the constants.
- */
-void t_as3_generator::generate_consts(std::vector<t_const*> consts) {
-  if (consts.empty()) {
-    return;
-  }
-
-  string f_consts_name = package_dir_ + "/" + program_name_ + "Constants.as";
-  ofstream_with_content_based_conditional_update f_consts;
-  f_consts.open(f_consts_name);
-
-  // Print header
-  f_consts << autogen_comment() << as3_package();
-
-  scope_up(f_consts);
-  f_consts << endl;
-
-  f_consts << as3_type_imports();
-
-  indent(f_consts) << "public class " << program_name_ << "Constants {" << endl << endl;
-  indent_up();
-  vector<t_const*>::iterator c_iter;
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    print_const_value(f_consts,
-                      (*c_iter)->get_name(),
-                      (*c_iter)->get_type(),
-                      (*c_iter)->get_value(),
-                      false);
-  }
-  indent_down();
-  indent(f_consts) << "}" << endl;
-  scope_down(f_consts);
-  f_consts.close();
-}
-
-void t_as3_generator::print_const_value(std::ostream& out,
-                                        string name,
-                                        t_type* type,
-                                        t_const_value* value,
-                                        bool in_static,
-                                        bool defval) {
-  type = get_true_type(type);
-
-  indent(out);
-  if (!defval) {
-    out << (in_static ? "var " : "public static const ");
-  }
-  if (type->is_base_type()) {
-    string v2 = render_const_value(out, name, type, value);
-    out << name;
-    if (!defval) {
-      out << ":" << type_name(type);
-    }
-    out << " = " << v2 << ";" << endl << endl;
-  } else if (type->is_enum()) {
-    out << name;
-    if (!defval) {
-      out << ":" << type_name(type);
-    }
-    out << " = " << value->get_integer() << ";" << endl << endl;
-  } else if (type->is_struct() || type->is_xception()) {
-    const vector<t_field*>& fields = ((t_struct*)type)->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    out << name << ":" << type_name(type) << " = new " << type_name(type, false, true) << "();"
-        << endl;
-    if (!in_static) {
-      indent(out) << "{" << endl;
-      indent_up();
-      indent(out) << "new function():void {" << endl;
-      indent_up();
-    }
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      t_type* field_type = NULL;
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field_type = (*f_iter)->get_type();
-        }
-      }
-      if (field_type == NULL) {
-        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
-      }
-      string val = render_const_value(out, name, field_type, v_iter->second);
-      indent(out) << name << ".";
-      out << v_iter->first->get_string() << " = " << val << ";" << endl;
-    }
-    if (!in_static) {
-      indent_down();
-      indent(out) << "}();" << endl;
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-    out << endl;
-  } else if (type->is_map()) {
-    out << name;
-    if (!defval) {
-      out << ":" << type_name(type);
-    }
-    out << " = new " << type_name(type, false, true) << "();" << endl;
-    if (!in_static) {
-      indent(out) << "{" << endl;
-      indent_up();
-      indent(out) << "new function():void {" << endl;
-      indent_up();
-    }
-    t_type* ktype = ((t_map*)type)->get_key_type();
-    t_type* vtype = ((t_map*)type)->get_val_type();
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string key = render_const_value(out, name, ktype, v_iter->first);
-      string val = render_const_value(out, name, vtype, v_iter->second);
-      indent(out) << name << "[" << key << "] = " << val << ";" << endl;
-    }
-    if (!in_static) {
-      indent_down();
-      indent(out) << "}();" << endl;
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-    out << endl;
-  } else if (type->is_list() || type->is_set()) {
-    out << name;
-    if (!defval) {
-      out << ":" << type_name(type);
-    }
-    out << " = new " << type_name(type, false, true) << "();" << endl;
-    if (!in_static) {
-      indent(out) << "{" << endl;
-      indent_up();
-      indent(out) << "new function():void {" << endl;
-      indent_up();
-    }
-    t_type* etype;
-    if (type->is_list()) {
-      etype = ((t_list*)type)->get_elem_type();
-    } else {
-      etype = ((t_set*)type)->get_elem_type();
-    }
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string val = render_const_value(out, name, etype, *v_iter);
-      indent(out) << name << "." << (type->is_list() ? "push" : "add") << "(" << val << ");"
-                  << endl;
-    }
-    if (!in_static) {
-      indent_down();
-      indent(out) << "}();" << endl;
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-    out << endl;
-  } else {
-    throw "compiler error: no const of type " + type->get_name();
-  }
-}
-
-string t_as3_generator::render_const_value(ostream& out,
-                                           string name,
-                                           t_type* type,
-                                           t_const_value* value) {
-  (void)name;
-  type = get_true_type(type);
-  std::ostringstream render;
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      render << '"' << get_escaped_string(value) << '"';
-      break;
-    case t_base_type::TYPE_BOOL:
-      render << ((value->get_integer() > 0) ? "true" : "false");
-      break;
-    case t_base_type::TYPE_I8:
-      render << "(byte)" << value->get_integer();
-      break;
-    case t_base_type::TYPE_I16:
-      render << "(short)" << value->get_integer();
-      break;
-    case t_base_type::TYPE_I32:
-      render << value->get_integer();
-      break;
-    case t_base_type::TYPE_I64:
-      render << value->get_integer() << "L";
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      if (value->get_type() == t_const_value::CV_INTEGER) {
-        render << "(double)" << value->get_integer();
-      } else {
-        render << value->get_double();
-      }
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else if (type->is_enum()) {
-    render << value->get_integer();
-  } else {
-    string t = tmp("tmp");
-    print_const_value(out, t, type, value, true);
-    render << t;
-  }
-
-  return render.str();
-}
-
-/**
- * Generates a struct definition for a thrift data type. This is a class
- * with data members, read(), write(), and an inner Isset class.
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_struct(t_struct* tstruct) {
-  generate_as3_struct(tstruct, false);
-}
-
-/**
- * Exceptions are structs, but they inherit from Exception
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_xception(t_struct* txception) {
-  generate_as3_struct(txception, true);
-}
-
-/**
- * As3 struct definition.
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_as3_struct(t_struct* tstruct, bool is_exception) {
-  // Make output file
-  string f_struct_name = package_dir_ + "/" + (tstruct->get_name()) + ".as";
-  ofstream_with_content_based_conditional_update f_struct;
-  f_struct.open(f_struct_name.c_str());
-
-  f_struct << autogen_comment() << as3_package();
-
-  scope_up(f_struct);
-  f_struct << endl;
-
-  string imports;
-
-  f_struct << as3_type_imports() << as3_thrift_imports() << as3_thrift_gen_imports(tstruct, imports)
-           << endl;
-
-  if (bindable_ && !is_exception) {
-    f_struct << "import flash.events.Event;" << endl << "import flash.events.EventDispatcher;"
-             << endl << "import mx.events.PropertyChangeEvent;" << endl;
-  }
-
-  generate_as3_struct_definition(f_struct, tstruct, is_exception);
-
-  scope_down(f_struct); // end of package
-  f_struct.close();
-}
-
-/**
- * As3 struct definition. This has various parameters, as it could be
- * generated standalone or inside another class as a helper. If it
- * is a helper than it is a static class.
- *
- * @param tstruct      The struct definition
- * @param is_exception Is this an exception?
- * @param in_class     If inside a class, needs to be static class
- * @param is_result    If this is a result it needs a different writer
- */
-void t_as3_generator::generate_as3_struct_definition(ostream& out,
-                                                     t_struct* tstruct,
-                                                     bool is_exception,
-                                                     bool in_class,
-                                                     bool is_result) {
-  generate_as3_doc(out, tstruct);
-
-  bool is_final = (tstruct->annotations_.find("final") != tstruct->annotations_.end());
-  bool bindable = !is_exception && !in_class && bindable_;
-
-  indent(out) << (in_class ? "" : "public ") << (is_final ? "final " : "") << "class "
-              << tstruct->get_name() << " ";
-
-  if (is_exception) {
-    out << "extends Error ";
-  } else if (bindable) {
-    out << "extends EventDispatcher ";
-  }
-  out << "implements TBase ";
-
-  scope_up(out);
-
-  indent(out) << "private static const STRUCT_DESC:TStruct = new TStruct(\"" << tstruct->get_name()
-              << "\");" << endl;
-
-  // Members are public for -as3, private for -as3bean
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    indent(out) << "private static const " << constant_name((*m_iter)->get_name())
-                << "_FIELD_DESC:TField = new TField(\"" << (*m_iter)->get_name() << "\", "
-                << type_to_enum((*m_iter)->get_type()) << ", " << (*m_iter)->get_key() << ");"
-                << endl;
-  }
-
-  out << endl;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    generate_as3_doc(out, *m_iter);
-    indent(out) << "private var _" << (*m_iter)->get_name() + ":" + type_name((*m_iter)->get_type())
-                << ";" << endl;
-
-    indent(out) << "public static const " << upcase_string((*m_iter)->get_name())
-                << ":int = " << (*m_iter)->get_key() << ";" << endl;
-  }
-
-  out << endl;
-
-  // Inner Isset class
-  if (members.size() > 0) {
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      if (!type_can_be_null((*m_iter)->get_type())) {
-        indent(out) << "private var __isset_" << (*m_iter)->get_name() << ":Boolean = false;"
-                    << endl;
-      }
-    }
-  }
-
-  out << endl;
-
-  generate_as3_meta_data_map(out, tstruct);
-
-  // Static initializer to populate global class to struct metadata map
-  indent(out) << "{" << endl;
-  indent_up();
-  indent(out) << "FieldMetaData.addStructMetaDataMap(" << type_name(tstruct) << ", metaDataMap);"
-              << endl;
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  // Default constructor
-  indent(out) << "public function " << tstruct->get_name() << "() {" << endl;
-  indent_up();
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    if ((*m_iter)->get_value() != NULL) {
-      indent(out) << "this._" << (*m_iter)->get_name() << " = "
-                  << (*m_iter)->get_value()->get_integer() << ";" << endl;
-    }
-  }
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  generate_as3_bean_boilerplate(out, tstruct, bindable);
-  generate_generic_field_getters_setters(out, tstruct);
-  generate_generic_isset_method(out, tstruct);
-
-  generate_as3_struct_reader(out, tstruct);
-  if (is_result) {
-    generate_as3_struct_result_writer(out, tstruct);
-  } else {
-    generate_as3_struct_writer(out, tstruct);
-  }
-  generate_as3_struct_tostring(out, tstruct, bindable);
-  generate_as3_validator(out, tstruct);
-  scope_down(out);
-  out << endl;
-}
-
-/**
- * Generates a function to read all the fields of the struct.
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_as3_struct_reader(ostream& out, t_struct* tstruct) {
-  out << indent() << "public function read(iprot:TProtocol):void {" << endl;
-  indent_up();
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  // Declare stack tmp variables and read struct header
-  out << indent() << "var field:TField;" << endl << indent() << "iprot.readStructBegin();" << endl;
-
-  // Loop over reading in fields
-  indent(out) << "while (true)" << endl;
-  scope_up(out);
-
-  // Read beginning field marker
-  indent(out) << "field = iprot.readFieldBegin();" << endl;
-
-  // Check for field STOP marker and break
-  indent(out) << "if (field.type == TType.STOP) { " << endl;
-  indent_up();
-  indent(out) << "break;" << endl;
-  indent_down();
-  indent(out) << "}" << endl;
-
-  // Switch statement on the field we are reading
-  indent(out) << "switch (field.id)" << endl;
-
-  scope_up(out);
-
-  // Generate deserialization code for known cases
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    indent(out) << "case " << upcase_string((*f_iter)->get_name()) << ":" << endl;
-    indent_up();
-    indent(out) << "if (field.type == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl;
-    indent_up();
-
-    generate_deserialize_field(out, *f_iter, "this.");
-    generate_isset_set(out, *f_iter);
-    indent_down();
-    out << indent() << "} else { " << endl << indent() << "  TProtocolUtil.skip(iprot, field.type);"
-        << endl << indent() << "}" << endl << indent() << "break;" << endl;
-    indent_down();
-  }
-
-  // In the default case we skip the field
-  out << indent() << "default:" << endl << indent() << "  TProtocolUtil.skip(iprot, field.type);"
-      << endl << indent() << "  break;" << endl;
-
-  scope_down(out);
-
-  // Read field end marker
-  indent(out) << "iprot.readFieldEnd();" << endl;
-
-  scope_down(out);
-
-  out << indent() << "iprot.readStructEnd();" << endl << endl;
-
-  // in non-beans style, check for required fields of primitive type
-  // (which can be checked here but not in the general validate method)
-  out << endl << indent() << "// check for required fields of primitive type, which can't be "
-                             "checked in the validate method" << endl;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if ((*f_iter)->get_req() == t_field::T_REQUIRED && !type_can_be_null((*f_iter)->get_type())) {
-      out << indent() << "if (!__isset_" << (*f_iter)->get_name() << ") {" << endl << indent()
-          << "  throw new TProtocolError(TProtocolError.UNKNOWN, \"Required field '"
-          << (*f_iter)->get_name()
-          << "' was not found in serialized data! Struct: \" + toString());" << endl << indent()
-          << "}" << endl;
-    }
-  }
-
-  // performs various checks (e.g. check that all required fields are set)
-  indent(out) << "validate();" << endl;
-
-  indent_down();
-  out << indent() << "}" << endl << endl;
-}
-
-// generates as3 method to perform various checks
-// (e.g. check that all required fields are set)
-void t_as3_generator::generate_as3_validator(ostream& out, t_struct* tstruct) {
-  indent(out) << "public function validate():void {" << endl;
-  indent_up();
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  out << indent() << "// check for required fields" << endl;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if ((*f_iter)->get_req() == t_field::T_REQUIRED) {
-      if (type_can_be_null((*f_iter)->get_type())) {
-        indent(out) << "if (" << (*f_iter)->get_name() << " == null) {" << endl;
-        indent(out) << "  throw new TProtocolError(TProtocolError.UNKNOWN, \"Required field '"
-                    << (*f_iter)->get_name() << "' was not present! Struct: \" + toString());"
-                    << endl;
-        indent(out) << "}" << endl;
-      } else {
-        indent(out) << "// alas, we cannot check '" << (*f_iter)->get_name()
-                    << "' because it's a primitive and you chose the non-beans generator." << endl;
-      }
-    }
-  }
-
-  // check that fields of type enum have valid values
-  out << indent() << "// check that fields of type enum have valid values" << endl;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_field* field = (*f_iter);
-    t_type* type = field->get_type();
-    // if field is an enum, check that its value is valid
-    if (type->is_enum()) {
-      indent(out) << "if (" << generate_isset_check(field) << " && !" << get_enum_class_name(type)
-                  << ".VALID_VALUES.contains(" << field->get_name() << ")){" << endl;
-      indent_up();
-      indent(out) << "throw new TProtocolError(TProtocolError.UNKNOWN, \"The field '"
-                  << field->get_name() << "' has been assigned the invalid value \" + "
-                  << field->get_name() << ");" << endl;
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-  }
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Generates a function to write all the fields of the struct
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_as3_struct_writer(ostream& out, t_struct* tstruct) {
-  out << indent() << "public function write(oprot:TProtocol):void {" << endl;
-  indent_up();
-
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_sorted_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  // performs various checks (e.g. check that all required fields are set)
-  indent(out) << "validate();" << endl << endl;
-
-  indent(out) << "oprot.writeStructBegin(STRUCT_DESC);" << endl;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    bool could_be_unset = (*f_iter)->get_req() == t_field::T_OPTIONAL;
-    if (could_be_unset) {
-      indent(out) << "if (" << generate_isset_check(*f_iter) << ") {" << endl;
-      indent_up();
-    }
-    bool null_allowed = type_can_be_null((*f_iter)->get_type());
-    if (null_allowed) {
-      out << indent() << "if (this." << (*f_iter)->get_name() << " != null) {" << endl;
-      indent_up();
-    }
-
-    indent(out) << "oprot.writeFieldBegin(" << constant_name((*f_iter)->get_name())
-                << "_FIELD_DESC);" << endl;
-
-    // Write field contents
-    generate_serialize_field(out, *f_iter, "this.");
-
-    // Write field closer
-    indent(out) << "oprot.writeFieldEnd();" << endl;
-
-    if (null_allowed) {
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-    if (could_be_unset) {
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-  }
-  // Write the struct map
-  out << indent() << "oprot.writeFieldStop();" << endl << indent() << "oprot.writeStructEnd();"
-      << endl;
-
-  indent_down();
-  out << indent() << "}" << endl << endl;
-}
-
-/**
- * Generates a function to write all the fields of the struct,
- * which is a function result. These fields are only written
- * if they are set in the Isset array, and only one of them
- * can be set at a time.
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_as3_struct_result_writer(ostream& out, t_struct* tstruct) {
-  out << indent() << "public function write(oprot:TProtocol):void {" << endl;
-  indent_up();
-
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_sorted_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  indent(out) << "oprot.writeStructBegin(STRUCT_DESC);" << endl;
-
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-      out << endl << indent() << "if ";
-    } else {
-      out << " else if ";
-    }
-
-    out << "(this." << generate_isset_check(*f_iter) << ") {" << endl;
-
-    indent_up();
-
-    indent(out) << "oprot.writeFieldBegin(" << constant_name((*f_iter)->get_name())
-                << "_FIELD_DESC);" << endl;
-
-    // Write field contents
-    generate_serialize_field(out, *f_iter, "this.");
-
-    // Write field closer
-    indent(out) << "oprot.writeFieldEnd();" << endl;
-
-    indent_down();
-    indent(out) << "}";
-  }
-  // Write the struct map
-  out << endl << indent() << "oprot.writeFieldStop();" << endl << indent()
-      << "oprot.writeStructEnd();" << endl;
-
-  indent_down();
-  out << indent() << "}" << endl << endl;
-}
-
-void t_as3_generator::generate_reflection_getters(ostringstream& out,
-                                                  t_type* type,
-                                                  string field_name,
-                                                  string cap_name) {
-  (void)type;
-  (void)cap_name;
-  indent(out) << "case " << upcase_string(field_name) << ":" << endl;
-  indent_up();
-  indent(out) << "return this." << field_name << ";" << endl;
-  indent_down();
-}
-
-void t_as3_generator::generate_reflection_setters(ostringstream& out,
-                                                  t_type* type,
-                                                  string field_name,
-                                                  string cap_name) {
-  (void)type;
-  (void)cap_name;
-  indent(out) << "case " << upcase_string(field_name) << ":" << endl;
-  indent_up();
-  indent(out) << "if (value == null) {" << endl;
-  indent(out) << "  unset" << get_cap_name(field_name) << "();" << endl;
-  indent(out) << "} else {" << endl;
-  indent(out) << "  this." << field_name << " = value;" << endl;
-  indent(out) << "}" << endl;
-  indent(out) << "break;" << endl << endl;
-
-  indent_down();
-}
-
-void t_as3_generator::generate_generic_field_getters_setters(std::ostream& out,
-                                                             t_struct* tstruct) {
-
-  std::ostringstream getter_stream;
-  std::ostringstream setter_stream;
-
-  // build up the bodies of both the getter and setter at once
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_field* field = *f_iter;
-    t_type* type = get_true_type(field->get_type());
-    std::string field_name = field->get_name();
-    std::string cap_name = get_cap_name(field_name);
-
-    indent_up();
-    generate_reflection_setters(setter_stream, type, field_name, cap_name);
-    generate_reflection_getters(getter_stream, type, field_name, cap_name);
-    indent_down();
-  }
-
-  // create the setter
-  indent(out) << "public function setFieldValue(fieldID:int, value:*):void {" << endl;
-  indent_up();
-
-  indent(out) << "switch (fieldID) {" << endl;
-
-  out << setter_stream.str();
-
-  indent(out) << "default:" << endl;
-  indent(out) << "  throw new ArgumentError(\"Field \" + fieldID + \" doesn't exist!\");" << endl;
-
-  indent(out) << "}" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  // create the getter
-  indent(out) << "public function getFieldValue(fieldID:int):* {" << endl;
-  indent_up();
-
-  indent(out) << "switch (fieldID) {" << endl;
-
-  out << getter_stream.str();
-
-  indent(out) << "default:" << endl;
-  indent(out) << "  throw new ArgumentError(\"Field \" + fieldID + \" doesn't exist!\");" << endl;
-
-  indent(out) << "}" << endl;
-
-  indent_down();
-
-  indent(out) << "}" << endl << endl;
-}
-
-// Creates a generic isSet method that takes the field number as argument
-void t_as3_generator::generate_generic_isset_method(std::ostream& out, t_struct* tstruct) {
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  // create the isSet method
-  indent(out) << "// Returns true if field corresponding to fieldID is set (has been assigned a "
-                 "value) and false otherwise" << endl;
-  indent(out) << "public function isSet(fieldID:int):Boolean {" << endl;
-  indent_up();
-  indent(out) << "switch (fieldID) {" << endl;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_field* field = *f_iter;
-    indent(out) << "case " << upcase_string(field->get_name()) << ":" << endl;
-    indent_up();
-    indent(out) << "return " << generate_isset_check(field) << ";" << endl;
-    indent_down();
-  }
-
-  indent(out) << "default:" << endl;
-  indent(out) << "  throw new ArgumentError(\"Field \" + fieldID + \" doesn't exist!\");" << endl;
-
-  indent(out) << "}" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Generates a set of As3 Bean boilerplate functions (setters, getters, etc.)
- * for the given struct.
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_as3_bean_boilerplate(ostream& out,
-                                                    t_struct* tstruct,
-                                                    bool bindable) {
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_field* field = *f_iter;
-    t_type* type = get_true_type(field->get_type());
-    std::string field_name = field->get_name();
-    std::string cap_name = get_cap_name(field_name);
-
-    // Simple getter
-    generate_as3_doc(out, field);
-    indent(out) << "public function get " << field_name << "():" << type_name(type) << " {" << endl;
-    indent_up();
-    indent(out) << "return this._" << field_name << ";" << endl;
-    indent_down();
-    indent(out) << "}" << endl << endl;
-
-    // Simple setter
-    generate_as3_doc(out, field);
-    std::string propName = tmp("thriftPropertyChange");
-    if (bindable) {
-      indent(out) << "[Bindable(event=\"" << propName << "\")]" << endl;
-    }
-    indent(out) << "public function set " << field_name << "(" << field_name << ":"
-                << type_name(type) << "):void {" << endl;
-    indent_up();
-    indent(out) << "this._" << field_name << " = " << field_name << ";" << endl;
-    generate_isset_set(out, field);
-
-    if (bindable) {
-      // We have to use a custom event rather than the default, because if you use the default,
-      // the setter only gets called if the value has changed - this means calling
-      // foo.setIntValue(0)
-      // will not cause foo.isIntValueSet() to return true since the value of foo._intValue wasn't
-      // changed
-      // so the setter was never called.
-      indent(out) << "dispatchEvent(new Event(\"" << propName << "\"));" << endl;
-
-      // However, if you just use a custom event, then collections won't be able to detect when
-      // elements
-      // in the collections have changed since they listed for PropertyChangeEvents.  So, we
-      // dispatch both.
-      indent(out) << "dispatchEvent(new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE));"
-                  << endl;
-    }
-    indent_down();
-    indent(out) << "}" << endl << endl;
-
-    // Unsetter
-    indent(out) << "public function unset" << cap_name << "():void {" << endl;
-    indent_up();
-    if (type_can_be_null(type)) {
-      indent(out) << "this." << field_name << " = null;" << endl;
-    } else {
-      indent(out) << "this.__isset_" << field_name << " = false;" << endl;
-    }
-    indent_down();
-    indent(out) << "}" << endl << endl;
-
-    // isSet method
-    indent(out) << "// Returns true if field " << field_name
-                << " is set (has been assigned a value) and false otherwise" << endl;
-    indent(out) << "public function is" << get_cap_name("set") << cap_name << "():Boolean {"
-                << endl;
-    indent_up();
-    if (type_can_be_null(type)) {
-      indent(out) << "return this." << field_name << " != null;" << endl;
-    } else {
-      indent(out) << "return this.__isset_" << field_name << ";" << endl;
-    }
-    indent_down();
-    indent(out) << "}" << endl << endl;
-  }
-}
-
-/**
- * Generates a toString() method for the given struct
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_as3_struct_tostring(ostream& out,
-                                                   t_struct* tstruct,
-                                                   bool bindable) {
-  // If it's bindable, it extends EventDispatcher so toString is an override.
-  out << indent() << "public " << (bindable ? "override " : "") << "function toString():String {"
-      << endl;
-  indent_up();
-
-  out << indent() << "var ret:String = new String(\"" << tstruct->get_name() << "(\");" << endl;
-  out << indent() << "var first:Boolean = true;" << endl << endl;
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    bool could_be_unset = (*f_iter)->get_req() == t_field::T_OPTIONAL;
-    if (could_be_unset) {
-      indent(out) << "if (" << generate_isset_check(*f_iter) << ") {" << endl;
-      indent_up();
-    }
-
-    t_field* field = (*f_iter);
-
-    if (!first) {
-      indent(out) << "if (!first) ret +=  \", \";" << endl;
-    }
-    indent(out) << "ret += \"" << (*f_iter)->get_name() << ":\";" << endl;
-    bool can_be_null = type_can_be_null(field->get_type());
-    if (can_be_null) {
-      indent(out) << "if (this." << (*f_iter)->get_name() << " == null) {" << endl;
-      indent(out) << "  ret += \"null\";" << endl;
-      indent(out) << "} else {" << endl;
-      indent_up();
-    }
-
-    if (field->get_type()->is_binary()) {
-      indent(out) << "  ret += \"BINARY\";" << endl;
-    } else if (field->get_type()->is_enum()) {
-      indent(out) << "var " << field->get_name()
-                  << "_name:String = " << get_enum_class_name(field->get_type())
-                  << ".VALUES_TO_NAMES[this." << (*f_iter)->get_name() << "];" << endl;
-      indent(out) << "if (" << field->get_name() << "_name != null) {" << endl;
-      indent(out) << "  ret += " << field->get_name() << "_name;" << endl;
-      indent(out) << "  ret += \" (\";" << endl;
-      indent(out) << "}" << endl;
-      indent(out) << "ret += this." << field->get_name() << ";" << endl;
-      indent(out) << "if (" << field->get_name() << "_name != null) {" << endl;
-      indent(out) << "  ret += \")\";" << endl;
-      indent(out) << "}" << endl;
-    } else {
-      indent(out) << "ret += this." << (*f_iter)->get_name() << ";" << endl;
-    }
-
-    if (can_be_null) {
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-    indent(out) << "first = false;" << endl;
-
-    if (could_be_unset) {
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-    first = false;
-  }
-  out << indent() << "ret += \")\";" << endl << indent() << "return ret;" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Generates a static map with meta data to store information such as fieldID to
- * fieldName mapping
- *
- * @param tstruct The struct definition
- */
-void t_as3_generator::generate_as3_meta_data_map(ostream& out, t_struct* tstruct) {
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  // Static Map with fieldID -> FieldMetaData mappings
-  indent(out) << "public static const metaDataMap:Dictionary = new Dictionary();" << endl;
-
-  if (fields.size() > 0) {
-    // Populate map
-    scope_up(out);
-    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-      t_field* field = *f_iter;
-      std::string field_name = field->get_name();
-      indent(out) << "metaDataMap[" << upcase_string(field_name) << "] = new FieldMetaData(\""
-                  << field_name << "\", ";
-
-      // Set field requirement type (required, optional, etc.)
-      if (field->get_req() == t_field::T_REQUIRED) {
-        out << "TFieldRequirementType.REQUIRED, ";
-      } else if (field->get_req() == t_field::T_OPTIONAL) {
-        out << "TFieldRequirementType.OPTIONAL, ";
-      } else {
-        out << "TFieldRequirementType.DEFAULT, ";
-      }
-
-      // Create value meta data
-      generate_field_value_meta_data(out, field->get_type());
-      out << ");" << endl;
-    }
-    scope_down(out);
-  }
-}
-
-/**
- * Returns a string with the as3 representation of the given thrift type
- * (e.g. for the type struct it returns "TType.STRUCT")
- */
-std::string t_as3_generator::get_as3_type_string(t_type* type) {
-  if (type->is_list()) {
-    return "TType.LIST";
-  } else if (type->is_map()) {
-    return "TType.MAP";
-  } else if (type->is_set()) {
-    return "TType.SET";
-  } else if (type->is_struct() || type->is_xception()) {
-    return "TType.STRUCT";
-  } else if (type->is_enum()) {
-    return "TType.I32";
-  } else if (type->is_typedef()) {
-    return get_as3_type_string(((t_typedef*)type)->get_type());
-  } else if (type->is_base_type()) {
-    switch (((t_base_type*)type)->get_base()) {
-    case t_base_type::TYPE_VOID:
-      return "TType.VOID";
-      break;
-    case t_base_type::TYPE_STRING:
-      return "TType.STRING";
-      break;
-    case t_base_type::TYPE_BOOL:
-      return "TType.BOOL";
-      break;
-    case t_base_type::TYPE_I8:
-      return "TType.BYTE";
-      break;
-    case t_base_type::TYPE_I16:
-      return "TType.I16";
-      break;
-    case t_base_type::TYPE_I32:
-      return "TType.I32";
-      break;
-    case t_base_type::TYPE_I64:
-      return "TType.I64";
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      return "TType.DOUBLE";
-      break;
-    default:
-      throw std::runtime_error("Unknown thrift type \"" + type->get_name()
-                               + "\" passed to t_as3_generator::get_as3_type_string!");
-      break; // This should never happen!
-    }
-  } else {
-    throw std::runtime_error(
-        "Unknown thrift type \"" + type->get_name()
-        + "\" passed to t_as3_generator::get_as3_type_string!"); // This should never happen!
-  }
-}
-
-void t_as3_generator::generate_field_value_meta_data(std::ostream& out, t_type* type) {
-  out << endl;
-  indent_up();
-  indent_up();
-  if (type->is_struct() || type->is_xception()) {
-    indent(out) << "new StructMetaData(TType.STRUCT, " << type_name(type);
-  } else if (type->is_container()) {
-    if (type->is_list()) {
-      indent(out) << "new ListMetaData(TType.LIST, ";
-      t_type* elem_type = ((t_list*)type)->get_elem_type();
-      generate_field_value_meta_data(out, elem_type);
-    } else if (type->is_set()) {
-      indent(out) << "new SetMetaData(TType.SET, ";
-      t_type* elem_type = ((t_list*)type)->get_elem_type();
-      generate_field_value_meta_data(out, elem_type);
-    } else { // map
-      indent(out) << "new MapMetaData(TType.MAP, ";
-      t_type* key_type = ((t_map*)type)->get_key_type();
-      t_type* val_type = ((t_map*)type)->get_val_type();
-      generate_field_value_meta_data(out, key_type);
-      out << ", ";
-      generate_field_value_meta_data(out, val_type);
-    }
-  } else {
-    indent(out) << "new FieldValueMetaData(" << get_as3_type_string(type);
-  }
-  out << ")";
-  indent_down();
-  indent_down();
-}
-
-/**
- * Generates a thrift service. In C++, this comprises an entirely separate
- * header and source file. The header file defines the methods and includes
- * the data types defined in the main header file, and the implementation
- * file contains implementations of the basic printer and default interfaces.
- *
- * @param tservice The service definition
- */
-void t_as3_generator::generate_service(t_service* tservice) {
-  // Make interface file
-  string f_service_name = package_dir_ + "/" + service_name_ + ".as";
-  f_service_.open(f_service_name.c_str());
-
-  f_service_ << autogen_comment() << as3_package();
-
-  scope_up(f_service_);
-
-  f_service_ << endl << as3_type_imports() << as3_thrift_imports()
-             << as3_thrift_gen_imports(tservice);
-
-  if (tservice->get_extends() != NULL) {
-    t_type* parent = tservice->get_extends();
-    string parent_namespace = parent->get_program()->get_namespace("as3");
-    if (!parent_namespace.empty() && parent_namespace != package_name_) {
-      f_service_ << "import " << type_name(parent) << ";" << endl;
-    }
-  }
-
-  f_service_ << endl;
-
-  generate_service_interface(tservice);
-
-  scope_down(f_service_);
-  f_service_.close();
-
-  // Now make the implementation/client file
-  f_service_name = package_dir_ + "/" + service_name_ + "Impl.as";
-  f_service_.open(f_service_name.c_str());
-
-  f_service_ << autogen_comment() << as3_package();
-
-  scope_up(f_service_);
-
-  f_service_ << endl << as3_type_imports() << as3_thrift_imports()
-             << as3_thrift_gen_imports(tservice);
-
-  if (tservice->get_extends() != NULL) {
-    t_type* parent = tservice->get_extends();
-    string parent_namespace = parent->get_program()->get_namespace("as3");
-    if (!parent_namespace.empty() && parent_namespace != package_name_) {
-      f_service_ << "import " << type_name(parent) << "Impl;" << endl;
-    }
-  }
-
-  f_service_ << endl;
-
-  generate_service_client(tservice);
-  scope_down(f_service_);
-
-  f_service_ << as3_type_imports();
-  f_service_ << as3_thrift_imports();
-  f_service_ << as3_thrift_gen_imports(tservice);
-  if (!package_name_.empty()) {
-    f_service_ << "import " << package_name_ << ".*;" << endl;
-  }
-
-  generate_service_helpers(tservice);
-
-  f_service_.close();
-
-  // Now make the processor/server file
-  f_service_name = package_dir_ + "/" + service_name_ + "Processor.as";
-  f_service_.open(f_service_name.c_str());
-
-  f_service_ << autogen_comment() << as3_package();
-
-  scope_up(f_service_);
-
-  f_service_ << endl << as3_type_imports() << as3_thrift_imports()
-             << as3_thrift_gen_imports(tservice) << endl;
-
-  generate_service_server(tservice);
-  scope_down(f_service_);
-
-  f_service_ << as3_type_imports();
-  f_service_ << as3_thrift_imports();
-  f_service_ << as3_thrift_gen_imports(tservice) << endl;
-  if (!package_name_.empty()) {
-    f_service_ << "import " << package_name_ << ".*;" << endl;
-  }
-
-  generate_service_helpers(tservice);
-
-  f_service_.close();
-}
-
-/**
- * Generates a service interface definition.
- *
- * @param tservice The service to generate a header definition for
- */
-void t_as3_generator::generate_service_interface(t_service* tservice) {
-  string extends_iface = "";
-  if (tservice->get_extends() != NULL) {
-    extends_iface = " extends " + tservice->get_extends()->get_name();
-  }
-
-  generate_as3_doc(f_service_, tservice);
-  f_service_ << indent() << "public interface " << service_name_ << extends_iface << " {" << endl
-             << endl;
-  indent_up();
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_as3_doc(f_service_, *f_iter);
-    if (!(*f_iter)->is_oneway()) {
-      if ((*f_iter)->get_returntype()->is_void()) {
-        indent(f_service_) << "//function onError(Error):void;" << endl;
-        indent(f_service_) << "//function onSuccess():void;" << endl;
-      } else {
-        indent(f_service_) << "//function onError(Error):void;" << endl;
-        indent(f_service_) << "//function onSuccess(" << type_name((*f_iter)->get_returntype())
-                           << "):void;" << endl;
-      }
-    }
-    indent(f_service_) << function_signature(*f_iter) << ";" << endl << endl;
-  }
-  indent_down();
-  f_service_ << indent() << "}" << endl << endl;
-}
-
-/**
- * Generates structs for all the service args and return types
- *
- * @param tservice The service
- */
-void t_as3_generator::generate_service_helpers(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    t_struct* ts = (*f_iter)->get_arglist();
-    generate_as3_struct_definition(f_service_, ts, false, true);
-    generate_function_helpers(*f_iter);
-  }
-}
-
-/**
- * Generates a service client definition.
- *
- * @param tservice The service to generate a server for.
- */
-void t_as3_generator::generate_service_client(t_service* tservice) {
-  string extends = "";
-  string extends_client = "";
-  if (tservice->get_extends() != NULL) {
-    extends = tservice->get_extends()->get_name();
-    extends_client = " extends " + extends + "Impl";
-  }
-
-  indent(f_service_) << "public class " << service_name_ << "Impl" << extends_client
-                     << " implements " << service_name_ << " {" << endl;
-  indent_up();
-
-  indent(f_service_) << "public function " << service_name_ << "Impl"
-                     << "(iprot:TProtocol, oprot:TProtocol=null)" << endl;
-  scope_up(f_service_);
-  if (extends.empty()) {
-    f_service_ << indent() << "iprot_ = iprot;" << endl;
-    f_service_ << indent() << "if (oprot == null) {" << endl;
-    indent_up();
-    f_service_ << indent() << "oprot_ = iprot;" << endl;
-    indent_down();
-    f_service_ << indent() << "} else {" << endl;
-    indent_up();
-    f_service_ << indent() << "oprot_ = oprot;" << endl;
-    indent_down();
-    f_service_ << indent() << "}";
-  } else {
-    f_service_ << indent() << "super(iprot, oprot);" << endl;
-  }
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  if (extends.empty()) {
-    f_service_ << indent() << "protected var iprot_:TProtocol;" << endl << indent()
-               << "protected var oprot_:TProtocol;" << endl << endl << indent()
-               << "protected var seqid_:int;" << endl << endl;
-
-    indent(f_service_) << "public function getInputProtocol():TProtocol" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "return this.iprot_;" << endl;
-    scope_down(f_service_);
-    f_service_ << endl;
-
-    indent(f_service_) << "public function getOutputProtocol():TProtocol" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "return this.oprot_;" << endl;
-    scope_down(f_service_);
-    f_service_ << endl;
-  }
-
-  // Generate client method implementations
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    string funname = (*f_iter)->get_name();
-
-    // Open function
-    if (!(*f_iter)->is_oneway()) {
-      if ((*f_iter)->get_returntype()->is_void()) {
-        indent(f_service_) << "//function onError(Error):void;" << endl;
-        indent(f_service_) << "//function onSuccess():void;" << endl;
-      } else {
-        indent(f_service_) << "//function onError(Error):void;" << endl;
-        indent(f_service_) << "//function onSuccess(" << type_name((*f_iter)->get_returntype())
-                           << "):void;" << endl;
-      }
-    }
-    indent(f_service_) << "public " << function_signature(*f_iter) << endl;
-    scope_up(f_service_);
-
-    // Get the struct of function call params
-    t_struct* arg_struct = (*f_iter)->get_arglist();
-
-    string argsname = (*f_iter)->get_name() + "_args";
-    vector<t_field*>::const_iterator fld_iter;
-    const vector<t_field*>& fields = arg_struct->get_members();
-
-    // Serialize the request
-    f_service_ << indent() << "oprot_.writeMessageBegin(new TMessage(\"" << funname << "\", "
-               << ((*f_iter)->is_oneway() ? "TMessageType.ONEWAY" : "TMessageType.CALL")
-               << ", seqid_));" << endl << indent() << "var args:" << argsname << " = new "
-               << argsname << "();" << endl;
-
-    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-      f_service_ << indent() << "args." << (*fld_iter)->get_name() << " = "
-                 << (*fld_iter)->get_name() << ";" << endl;
-    }
-
-    f_service_ << indent() << "args.write(oprot_);" << endl << indent()
-               << "oprot_.writeMessageEnd();" << endl;
-
-    if ((*f_iter)->is_oneway()) {
-      f_service_ << indent() << "oprot_.getTransport().flush();" << endl;
-    } else {
-      f_service_ << indent() << "oprot_.getTransport().flush(function(error:Error):void {" << endl;
-      indent_up();
-      f_service_ << indent() << "try {" << endl;
-      indent_up();
-      string resultname = (*f_iter)->get_name() + "_result";
-      f_service_ << indent() << "if (error != null) {" << endl << indent()
-                 << "  if (onError != null) onError(error);" << endl << indent() << "  return;"
-                 << endl << indent() << "}" << endl << indent()
-                 << "var msg:TMessage = iprot_.readMessageBegin();" << endl << indent()
-                 << "if (msg.type == TMessageType.EXCEPTION) {" << endl << indent()
-                 << "  var x:TApplicationError = TApplicationError.read(iprot_);" << endl
-                 << indent() << "  iprot_.readMessageEnd();" << endl << indent()
-                 << "  if (onError != null) onError(x);" << endl << indent() << "  return;" << endl
-                 << indent() << "}" << endl << indent() << "var result :" << resultname << " = new "
-                 << resultname << "();" << endl << indent() << "result.read(iprot_);" << endl
-                 << indent() << "iprot_.readMessageEnd();" << endl;
-
-      // Careful, only return _result if not a void function
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        f_service_ << indent() << "if (result." << generate_isset_check("success") << ") {" << endl
-                   << indent() << "  if (onSuccess != null) onSuccess(result.success);" << endl
-                   << indent() << "  return;" << endl << indent() << "}" << endl;
-      }
-
-      t_struct* xs = (*f_iter)->get_xceptions();
-      const std::vector<t_field*>& xceptions = xs->get_members();
-      vector<t_field*>::const_iterator x_iter;
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-        f_service_ << indent() << "if (result." << (*x_iter)->get_name() << " != null) {" << endl
-                   << indent() << "  if (onError != null) onError(result." << (*x_iter)->get_name()
-                   << ");" << endl << indent() << "  return;" << endl << indent() << "}" << endl;
-      }
-
-      // If you get here it's an exception, unless a void function
-      if ((*f_iter)->get_returntype()->is_void()) {
-        f_service_ << indent() << "if (onSuccess != null) onSuccess();" << endl << indent()
-                   << "return;" << endl;
-      } else {
-
-        f_service_ << indent() << "if (onError != null) onError(new "
-                                  "TApplicationError(TApplicationError.MISSING_RESULT, \""
-                   << (*f_iter)->get_name() << " failed: unknown result\"));" << endl;
-      }
-      indent_down();
-      f_service_ << indent() << "} catch (e:TError) {" << endl << indent()
-                 << "  if (onError != null) onError(e);" << endl << indent() << "}" << endl;
-
-      indent_down();
-      indent(f_service_) << "});" << endl;
-    }
-    // Close function
-    scope_down(f_service_);
-    f_service_ << endl;
-  }
-
-  indent_down();
-  indent(f_service_) << "}" << endl;
-}
-
-/**
- * Generates a service server definition.
- *
- * @param tservice The service to generate a server for.
- */
-void t_as3_generator::generate_service_server(t_service* tservice) {
-  // Generate the dispatch methods
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-
-  // Extends stuff
-  string extends = "";
-  string extends_processor = "";
-  if (tservice->get_extends() != NULL) {
-    extends = type_name(tservice->get_extends());
-    extends_processor = " extends " + extends + "Processor";
-  }
-
-  // Generate the header portion
-  indent(f_service_) << "public class " << service_name_ << "Processor" << extends_processor
-                     << " implements TProcessor {" << endl;
-  indent_up();
-
-  indent(f_service_) << "public function " << service_name_ << "Processor(iface:" << service_name_
-                     << ")" << endl;
-  scope_up(f_service_);
-  if (!extends.empty()) {
-    f_service_ << indent() << "super(iface);" << endl;
-  }
-  f_service_ << indent() << "iface_ = iface;" << endl;
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    f_service_ << indent() << "PROCESS_MAP[\"" << (*f_iter)->get_name()
-               << "\"] = " << (*f_iter)->get_name() << "();" << endl;
-  }
-
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  f_service_ << indent() << "private var iface_:" << service_name_ << ";" << endl;
-
-  if (extends.empty()) {
-    f_service_ << indent() << "protected const PROCESS_MAP:Dictionary = new Dictionary();" << endl;
-  }
-
-  f_service_ << endl;
-
-  // Generate the server implementation
-  string override = "";
-  if (tservice->get_extends() != NULL) {
-    override = "override ";
-  }
-  indent(f_service_) << override
-                     << "public function process(iprot:TProtocol, oprot:TProtocol):Boolean" << endl;
-  scope_up(f_service_);
-
-  f_service_ << indent() << "var msg:TMessage = iprot.readMessageBegin();" << endl;
-
-  // TODO(mcslee): validate message, was the seqid etc. legit?
-  // AS- If all method is oneway:
-  // do you have an oprot?
-  // do you you need nullcheck?
-  f_service_
-      << indent() << "var fn:Function = PROCESS_MAP[msg.name];" << endl << indent()
-      << "if (fn == null) {" << endl << indent() << "  TProtocolUtil.skip(iprot, TType.STRUCT);"
-      << endl << indent() << "  iprot.readMessageEnd();" << endl << indent()
-      << "  var x:TApplicationError = new TApplicationError(TApplicationError.UNKNOWN_METHOD, "
-         "\"Invalid method name: '\"+msg.name+\"'\");" << endl << indent()
-      << "  oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));"
-      << endl << indent() << "  x.write(oprot);" << endl << indent() << "  oprot.writeMessageEnd();"
-      << endl << indent() << "  oprot.getTransport().flush();" << endl << indent()
-      << "  return true;" << endl << indent() << "}" << endl << indent()
-      << "fn.call(this,msg.seqid, iprot, oprot);" << endl;
-
-  f_service_ << indent() << "return true;" << endl;
-
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate the process subfunctions
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_process_function(tservice, *f_iter);
-  }
-
-  indent_down();
-  indent(f_service_) << "}" << endl << endl;
-}
-
-/**
- * Generates a struct and helpers for a function.
- *
- * @param tfunction The function
- */
-void t_as3_generator::generate_function_helpers(t_function* tfunction) {
-  if (tfunction->is_oneway()) {
-    return;
-  }
-
-  t_struct result(program_, tfunction->get_name() + "_result");
-  t_field success(tfunction->get_returntype(), "success", 0);
-  if (!tfunction->get_returntype()->is_void()) {
-    result.append(&success);
-  }
-
-  t_struct* xs = tfunction->get_xceptions();
-  const vector<t_field*>& fields = xs->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    result.append(*f_iter);
-  }
-
-  generate_as3_struct_definition(f_service_, &result, false, true, true);
-}
-
-/**
- * Generates a process function definition.
- *
- * @param tfunction The function to write a dispatcher for
- */
-void t_as3_generator::generate_process_function(t_service* tservice, t_function* tfunction) {
-  (void)tservice;
-  // Open class
-  indent(f_service_) << "private function " << tfunction->get_name() << "():Function {" << endl;
-  indent_up();
-
-  // Open function
-  indent(f_service_) << "return function(seqid:int, iprot:TProtocol, oprot:TProtocol):void" << endl;
-  scope_up(f_service_);
-
-  string argsname = tfunction->get_name() + "_args";
-  string resultname = tfunction->get_name() + "_result";
-
-  f_service_ << indent() << "var args:" << argsname << " = new " << argsname << "();" << endl
-             << indent() << "args.read(iprot);" << endl << indent() << "iprot.readMessageEnd();"
-             << endl;
-
-  t_struct* xs = tfunction->get_xceptions();
-  const std::vector<t_field*>& xceptions = xs->get_members();
-  vector<t_field*>::const_iterator x_iter;
-
-  // Declare result for non oneway function
-  if (!tfunction->is_oneway()) {
-    f_service_ << indent() << "var result:" << resultname << " = new " << resultname << "();"
-               << endl;
-  }
-
-  // Try block for a function with exceptions
-  if (xceptions.size() > 0) {
-    f_service_ << indent() << "try {" << endl;
-    indent_up();
-  }
-
-  // Generate the function call
-  t_struct* arg_struct = tfunction->get_arglist();
-  const std::vector<t_field*>& fields = arg_struct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  f_service_ << indent();
-  if (tfunction->is_oneway()) {
-    f_service_ << "iface_." << tfunction->get_name() << "(";
-    bool first = true;
-    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-      if (first) {
-        first = false;
-      } else {
-        f_service_ << ", ";
-      }
-      f_service_ << "args." << (*f_iter)->get_name();
-    }
-    f_service_ << ");" << endl;
-  } else {
-    f_service_ << "// sorry this operation is not supported yet" << endl;
-    f_service_ << indent() << "throw new Error(\"This is not yet supported\");" << endl;
-  }
-
-  // Set isset on success field
-  if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()
-      && !type_can_be_null(tfunction->get_returntype())) {
-    f_service_ << indent() << "result.set" << get_cap_name("success") << get_cap_name("isSet")
-               << "(true);" << endl;
-  }
-
-  if (!tfunction->is_oneway() && xceptions.size() > 0) {
-    indent_down();
-    f_service_ << indent() << "}";
-    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-      f_service_ << " catch (" << (*x_iter)->get_name() << ":"
-                 << type_name((*x_iter)->get_type(), false, false) << ") {" << endl;
-      if (!tfunction->is_oneway()) {
-        indent_up();
-        f_service_ << indent() << "result." << (*x_iter)->get_name() << " = "
-                   << (*x_iter)->get_name() << ";" << endl;
-        indent_down();
-        f_service_ << indent() << "}";
-      } else {
-        f_service_ << "}";
-      }
-    }
-    f_service_ << " catch (th:Error) {" << endl;
-    indent_up();
-    f_service_ << indent() << "trace(\"Internal error processing " << tfunction->get_name()
-               << "\", th);" << endl << indent()
-               << "var x:TApplicationError = new "
-                  "TApplicationError(TApplicationError.INTERNAL_ERROR, \"Internal error processing "
-               << tfunction->get_name() << "\");" << endl << indent()
-               << "oprot.writeMessageBegin(new TMessage(\"" << tfunction->get_name()
-               << "\", TMessageType.EXCEPTION, seqid));" << endl << indent() << "x.write(oprot);"
-               << endl << indent() << "oprot.writeMessageEnd();" << endl << indent()
-               << "oprot.getTransport().flush();" << endl << indent() << "return;" << endl;
-    indent_down();
-    f_service_ << indent() << "}" << endl;
-  }
-
-  // Shortcut out here for oneway functions
-  if (tfunction->is_oneway()) {
-    f_service_ << indent() << "return;" << endl;
-    scope_down(f_service_);
-
-    // Close class
-    indent_down();
-    f_service_ << indent() << "}" << endl << endl;
-    return;
-  }
-
-  f_service_ << indent() << "oprot.writeMessageBegin(new TMessage(\"" << tfunction->get_name()
-             << "\", TMessageType.REPLY, seqid));" << endl << indent() << "result.write(oprot);"
-             << endl << indent() << "oprot.writeMessageEnd();" << endl << indent()
-             << "oprot.getTransport().flush();" << endl;
-
-  // Close function
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Close class
-  indent_down();
-  f_service_ << indent() << "}" << endl << endl;
-}
-
-/**
- * Deserializes a field of any type.
- *
- * @param tfield The field
- * @param prefix The variable name or container for this field
- */
-void t_as3_generator::generate_deserialize_field(ostream& out, t_field* tfield, string prefix) {
-  t_type* type = get_true_type(tfield->get_type());
-
-  if (type->is_void()) {
-    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name();
-  }
-
-  string name = prefix + tfield->get_name();
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_deserialize_struct(out, (t_struct*)type, name);
-  } else if (type->is_container()) {
-    generate_deserialize_container(out, type, name);
-  } else if (type->is_base_type() || type->is_enum()) {
-
-    indent(out) << name << " = iprot.";
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + name;
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "readBinary();";
-        } else {
-          out << "readString();";
-        }
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "readBool();";
-        break;
-      case t_base_type::TYPE_I8:
-        out << "readByte();";
-        break;
-      case t_base_type::TYPE_I16:
-        out << "readI16();";
-        break;
-      case t_base_type::TYPE_I32:
-        out << "readI32();";
-        break;
-      case t_base_type::TYPE_I64:
-        out << "readI64();";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "readDouble();";
-        break;
-      default:
-        throw "compiler error: no As3 name for base type " + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      out << "readI32();";
-    }
-    out << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n",
-           tfield->get_name().c_str(),
-           type_name(type).c_str());
-  }
-}
-
-/**
- * Generates an unserializer for a struct, invokes read()
- */
-void t_as3_generator::generate_deserialize_struct(ostream& out, t_struct* tstruct, string prefix) {
-  out << indent() << prefix << " = new " << type_name(tstruct) << "();" << endl << indent()
-      << prefix << ".read(iprot);" << endl;
-}
-
-/**
- * Deserializes a container by reading its size and then iterating
- */
-void t_as3_generator::generate_deserialize_container(ostream& out, t_type* ttype, string prefix) {
-  scope_up(out);
-
-  string obj;
-
-  if (ttype->is_map()) {
-    obj = tmp("_map");
-  } else if (ttype->is_set()) {
-    obj = tmp("_set");
-  } else if (ttype->is_list()) {
-    obj = tmp("_list");
-  }
-
-  // Declare variables, read header
-  if (ttype->is_map()) {
-    indent(out) << "var " << obj << ":TMap = iprot.readMapBegin();" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "var " << obj << ":TSet = iprot.readSetBegin();" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "var " << obj << ":TList = iprot.readListBegin();" << endl;
-  }
-
-  indent(out) << prefix << " = new " << type_name(ttype, false, true)
-              // size the collection correctly
-              << "("
-              << ");" << endl;
-
-  // For loop iterates over elements
-  string i = tmp("_i");
-  indent(out) << "for (var " << i << ":int = 0; " << i << " < " << obj << ".size"
-              << "; "
-              << "++" << i << ")" << endl;
-
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    generate_deserialize_map_element(out, (t_map*)ttype, prefix);
-  } else if (ttype->is_set()) {
-    generate_deserialize_set_element(out, (t_set*)ttype, prefix);
-  } else if (ttype->is_list()) {
-    generate_deserialize_list_element(out, (t_list*)ttype, prefix);
-  }
-
-  scope_down(out);
-
-  // Read container end
-  if (ttype->is_map()) {
-    indent(out) << "iprot.readMapEnd();" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "iprot.readSetEnd();" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "iprot.readListEnd();" << endl;
-  }
-
-  scope_down(out);
-}
-
-/**
- * Generates code to deserialize a map
- */
-void t_as3_generator::generate_deserialize_map_element(ostream& out, t_map* tmap, string prefix) {
-  string key = tmp("_key");
-  string val = tmp("_val");
-  t_field fkey(tmap->get_key_type(), key);
-  t_field fval(tmap->get_val_type(), val);
-
-  indent(out) << declare_field(&fkey) << endl;
-  indent(out) << declare_field(&fval) << endl;
-
-  generate_deserialize_field(out, &fkey);
-  generate_deserialize_field(out, &fval);
-
-  indent(out) << prefix << "[" << key << "] = " << val << ";" << endl;
-}
-
-/**
- * Deserializes a set element
- */
-void t_as3_generator::generate_deserialize_set_element(ostream& out, t_set* tset, string prefix) {
-  string elem = tmp("_elem");
-  t_field felem(tset->get_elem_type(), elem);
-
-  indent(out) << declare_field(&felem) << endl;
-
-  generate_deserialize_field(out, &felem);
-
-  indent(out) << prefix << ".add(" << elem << ");" << endl;
-}
-
-/**
- * Deserializes a list element
- */
-void t_as3_generator::generate_deserialize_list_element(ostream& out,
-                                                        t_list* tlist,
-                                                        string prefix) {
-  string elem = tmp("_elem");
-  t_field felem(tlist->get_elem_type(), elem);
-
-  indent(out) << declare_field(&felem) << endl;
-
-  generate_deserialize_field(out, &felem);
-
-  indent(out) << prefix << ".push(" << elem << ");" << endl;
-}
-
-/**
- * Serializes a field of any type.
- *
- * @param tfield The field to serialize
- * @param prefix Name to prepend to field name
- */
-void t_as3_generator::generate_serialize_field(ostream& out, t_field* tfield, string prefix) {
-  t_type* type = get_true_type(tfield->get_type());
-
-  // Do nothing for void types
-  if (type->is_void()) {
-    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name();
-  }
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_serialize_struct(out, (t_struct*)type, prefix + tfield->get_name());
-  } else if (type->is_container()) {
-    generate_serialize_container(out, type, prefix + tfield->get_name());
-  } else if (type->is_base_type() || type->is_enum()) {
-
-    string name = prefix + tfield->get_name();
-    indent(out) << "oprot.";
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + name;
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "writeBinary(" << name << ");";
-        } else {
-          out << "writeString(" << name << ");";
-        }
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "writeBool(" << name << ");";
-        break;
-      case t_base_type::TYPE_I8:
-        out << "writeByte(" << name << ");";
-        break;
-      case t_base_type::TYPE_I16:
-        out << "writeI16(" << name << ");";
-        break;
-      case t_base_type::TYPE_I32:
-        out << "writeI32(" << name << ");";
-        break;
-      case t_base_type::TYPE_I64:
-        out << "writeI64(" << name << ");";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "writeDouble(" << name << ");";
-        break;
-      default:
-        throw "compiler error: no As3 name for base type " + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      out << "writeI32(" << name << ");";
-    }
-    out << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s%s' TYPE '%s'\n",
-           prefix.c_str(),
-           tfield->get_name().c_str(),
-           type_name(type).c_str());
-  }
-}
-
-/**
- * Serializes all the members of a struct.
- *
- * @param tstruct The struct to serialize
- * @param prefix  String prefix to attach to all fields
- */
-void t_as3_generator::generate_serialize_struct(ostream& out, t_struct* tstruct, string prefix) {
-  (void)tstruct;
-  out << indent() << prefix << ".write(oprot);" << endl;
-}
-
-/**
- * Serializes a container by writing its size then the elements.
- *
- * @param ttype  The type of container
- * @param prefix String prefix for fields
- */
-void t_as3_generator::generate_serialize_container(ostream& out, t_type* ttype, string prefix) {
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    string iter = tmp("_key");
-    string counter = tmp("_sizeCounter");
-    indent(out) << "var " << counter << ":int = 0;" << endl;
-    indent(out) << "for (var " << iter << ":* in " << prefix << ") {" << endl;
-    indent(out) << "  " << counter << +"++;" << endl;
-    indent(out) << "}" << endl;
-
-    indent(out) << "oprot.writeMapBegin(new TMap(" << type_to_enum(((t_map*)ttype)->get_key_type())
-                << ", " << type_to_enum(((t_map*)ttype)->get_val_type()) << ", " << counter << "));"
-                << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "oprot.writeSetBegin(new TSet(" << type_to_enum(((t_set*)ttype)->get_elem_type())
-                << ", " << prefix << ".size));" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "oprot.writeListBegin(new TList("
-                << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", " << prefix << ".length));"
-                << endl;
-  }
-
-  string iter = tmp("elem");
-  if (ttype->is_map()) {
-    indent(out) << "for (var " << iter << ":* in " << prefix << ")";
-  } else if (ttype->is_set()) {
-    indent(out) << "for each (var " << iter << ":* in " << prefix << ".toArray())";
-  } else if (ttype->is_list()) {
-    indent(out) << "for each (var " << iter << ":* in " << prefix << ")";
-  }
-
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    generate_serialize_map_element(out, (t_map*)ttype, iter, prefix);
-  } else if (ttype->is_set()) {
-    generate_serialize_set_element(out, (t_set*)ttype, iter);
-  } else if (ttype->is_list()) {
-    generate_serialize_list_element(out, (t_list*)ttype, iter);
-  }
-
-  scope_down(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "oprot.writeMapEnd();" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "oprot.writeSetEnd();" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "oprot.writeListEnd();" << endl;
-  }
-
-  scope_down(out);
-}
-
-/**
- * Serializes the members of a map.
- */
-void t_as3_generator::generate_serialize_map_element(ostream& out,
-                                                     t_map* tmap,
-                                                     string iter,
-                                                     string map) {
-  t_field kfield(tmap->get_key_type(), iter);
-  generate_serialize_field(out, &kfield, "");
-  t_field vfield(tmap->get_val_type(), map + "[" + iter + "]");
-  generate_serialize_field(out, &vfield, "");
-}
-
-/**
- * Serializes the members of a set.
- */
-void t_as3_generator::generate_serialize_set_element(ostream& out, t_set* tset, string iter) {
-  t_field efield(tset->get_elem_type(), iter);
-  generate_serialize_field(out, &efield, "");
-}
-
-/**
- * Serializes the members of a list.
- */
-void t_as3_generator::generate_serialize_list_element(ostream& out, t_list* tlist, string iter) {
-  t_field efield(tlist->get_elem_type(), iter);
-  generate_serialize_field(out, &efield, "");
-}
-
-/**
- * Returns a As3 type name
- *
- * @param ttype The type
- * @param container Is the type going inside a container?
- * @return As3 type name, i.e. HashMap<Key,Value>
- */
-string t_as3_generator::type_name(t_type* ttype, bool in_container, bool in_init) {
-  (void)in_init;
-  // In As3 typedefs are just resolved to their real type
-  ttype = get_true_type(ttype);
-  string prefix;
-
-  if (ttype->is_base_type()) {
-    return base_type_name((t_base_type*)ttype, in_container);
-  } else if (ttype->is_enum()) {
-    return "int";
-  } else if (ttype->is_map()) {
-    return "Dictionary";
-  } else if (ttype->is_set()) {
-    return "Set";
-  } else if (ttype->is_list()) {
-    return "Array";
-  }
-
-  // Check for namespacing
-  t_program* program = ttype->get_program();
-  if (program != NULL && program != program_) {
-    string package = program->get_namespace("as3");
-    if (!package.empty()) {
-      return package + "." + ttype->get_name();
-    }
-  }
-
-  return ttype->get_name();
-}
-
-/**
- * Returns the AS3 type that corresponds to the thrift type.
- *
- * @param tbase The base type
- * @param container Is it going in a As3 container?
- */
-string t_as3_generator::base_type_name(t_base_type* type, bool in_container) {
-  (void)in_container;
-  t_base_type::t_base tbase = type->get_base();
-
-  switch (tbase) {
-  case t_base_type::TYPE_VOID:
-    return "void";
-  case t_base_type::TYPE_STRING:
-    if (type->is_binary()) {
-      return "ByteArray";
-    } else {
-      return "String";
-    }
-  case t_base_type::TYPE_BOOL:
-    return "Boolean";
-  case t_base_type::TYPE_I8:
-  case t_base_type::TYPE_I16:
-  case t_base_type::TYPE_I32:
-    return "int";
-  case t_base_type::TYPE_I64:
-    throw "i64 is not yet supported in as3";
-  case t_base_type::TYPE_DOUBLE:
-    return "Number";
-  default:
-    throw "compiler error: no As3 name for base type " + t_base_type::t_base_name(tbase);
-  }
-}
-
-/**
- * Declares a field, which may include initialization as necessary.
- *
- * @param ttype The type
- */
-string t_as3_generator::declare_field(t_field* tfield, bool init) {
-  // TODO(mcslee): do we ever need to initialize the field?
-  string result = "var " + tfield->get_name() + ":" + type_name(tfield->get_type());
-  if (init) {
-    t_type* ttype = get_true_type(tfield->get_type());
-    if (ttype->is_base_type() && tfield->get_value() != NULL) {
-      std::ofstream dummy;
-      result += " = " + render_const_value(dummy, tfield->get_name(), ttype, tfield->get_value());
-    } else if (ttype->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "NO T_VOID CONSTRUCT";
-      case t_base_type::TYPE_STRING:
-        result += " = null";
-        break;
-      case t_base_type::TYPE_BOOL:
-        result += " = false";
-        break;
-      case t_base_type::TYPE_I8:
-      case t_base_type::TYPE_I16:
-      case t_base_type::TYPE_I32:
-      case t_base_type::TYPE_I64:
-        result += " = 0";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        result += " = (double)0";
-        break;
-      }
-
-    } else if (ttype->is_enum()) {
-      result += " = 0";
-    } else if (ttype->is_container()) {
-      result += " = new " + type_name(ttype, false, true) + "()";
-    } else {
-      result += " = new " + type_name(ttype, false, true) + "()";
-      ;
-    }
-  }
-  return result + ";";
-}
-
-/**
- * Renders a function signature of the form 'type name(args)'
- *
- * @param tfunction Function definition
- * @return String of rendered function definition
- */
-string t_as3_generator::function_signature(t_function* tfunction, string prefix) {
-  std::string arguments = argument_list(tfunction->get_arglist());
-  if (!tfunction->is_oneway()) {
-    if (arguments != "") {
-      arguments += ", ";
-    }
-    arguments += "onError:Function, onSuccess:Function";
-  }
-
-  std::string result = "function " + prefix + tfunction->get_name() + "(" + arguments + "):void";
-  return result;
-}
-
-/**
- * Renders a comma separated field list, with type names
- */
-string t_as3_generator::argument_list(t_struct* tstruct) {
-  string result = "";
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      result += ", ";
-    }
-    result += (*f_iter)->get_name() + ":" + type_name((*f_iter)->get_type());
-  }
-  return result;
-}
-
-/**
- * Converts the parse type to a C++ enum string for the given type.
- */
-string t_as3_generator::type_to_enum(t_type* type) {
-  type = get_true_type(type);
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "NO T_VOID CONSTRUCT";
-    case t_base_type::TYPE_STRING:
-      return "TType.STRING";
-    case t_base_type::TYPE_BOOL:
-      return "TType.BOOL";
-    case t_base_type::TYPE_I8:
-      return "TType.BYTE";
-    case t_base_type::TYPE_I16:
-      return "TType.I16";
-    case t_base_type::TYPE_I32:
-      return "TType.I32";
-    case t_base_type::TYPE_I64:
-      return "TType.I64";
-    case t_base_type::TYPE_DOUBLE:
-      return "TType.DOUBLE";
-    }
-  } else if (type->is_enum()) {
-    return "TType.I32";
-  } else if (type->is_struct() || type->is_xception()) {
-    return "TType.STRUCT";
-  } else if (type->is_map()) {
-    return "TType.MAP";
-  } else if (type->is_set()) {
-    return "TType.SET";
-  } else if (type->is_list()) {
-    return "TType.LIST";
-  }
-
-  throw "INVALID TYPE IN type_to_enum: " + type->get_name();
-}
-
-/**
- * Applies the correct style to a string based on the value of nocamel_style_
- */
-std::string t_as3_generator::get_cap_name(std::string name) {
-  name[0] = toupper(name[0]);
-  return name;
-}
-
-string t_as3_generator::constant_name(string name) {
-  string constant_name;
-
-  bool is_first = true;
-  bool was_previous_char_upper = false;
-  for (string::iterator iter = name.begin(); iter != name.end(); ++iter) {
-    string::value_type character = (*iter);
-
-    bool is_upper = isupper(character);
-
-    if (is_upper && !is_first && !was_previous_char_upper) {
-      constant_name += '_';
-    }
-    constant_name += toupper(character);
-
-    is_first = false;
-    was_previous_char_upper = is_upper;
-  }
-
-  return constant_name;
-}
-
-/**
- * Emits a As3Doc comment if the provided object has a doc in Thrift
- */
-void t_as3_generator::generate_as3_doc(ostream& out, t_doc* tdoc) {
-  if (tdoc->has_doc()) {
-    generate_docstring_comment(out, "/**\n", " * ", tdoc->get_doc(), " */\n");
-  }
-}
-
-/**
- * Emits a As3Doc comment if the provided function object has a doc in Thrift
- */
-void t_as3_generator::generate_as3_doc(ostream& out, t_function* tfunction) {
-  if (tfunction->has_doc()) {
-    stringstream ss;
-    ss << tfunction->get_doc();
-    const vector<t_field*>& fields = tfunction->get_arglist()->get_members();
-    vector<t_field*>::const_iterator p_iter;
-    for (p_iter = fields.begin(); p_iter != fields.end(); ++p_iter) {
-      t_field* p = *p_iter;
-      ss << "\n@param " << p->get_name();
-      if (p->has_doc()) {
-        ss << " " << p->get_doc();
-      }
-    }
-    generate_docstring_comment(out, "/**\n", " * ", ss.str(), " */\n");
-  }
-}
-
-std::string t_as3_generator::generate_isset_check(t_field* field) {
-  return generate_isset_check(field->get_name());
-}
-
-std::string t_as3_generator::generate_isset_check(std::string field_name) {
-  return "is" + get_cap_name("set") + get_cap_name(field_name) + "()";
-}
-
-void t_as3_generator::generate_isset_set(ostream& out, t_field* field) {
-  if (!type_can_be_null(field->get_type())) {
-    indent(out) << "this.__isset_" << field->get_name() << " = true;" << endl;
-  }
-}
-
-std::string t_as3_generator::get_enum_class_name(t_type* type) {
-  string package = "";
-  t_program* program = type->get_program();
-  if (program != NULL && program != program_) {
-    package = program->get_namespace("as3") + ".";
-  }
-  return package + type->get_name();
-}
-
-THRIFT_REGISTER_GENERATOR(
-    as3,
-    "AS3",
-    "    bindable:        Add [bindable] metadata to all the struct classes.\n")
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one 
+ * or more contributor license agreements. See the NOTICE file 
+ * distributed with this work for additional information 
+ * regarding copyright ownership. The ASF licenses this file 
+ * to you under the Apache License, Version 2.0 (the 
+ * "License"); you may not use this file except in compliance 
+ * with the License. You may obtain a copy of the License at 
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, 
+ * software distributed under the License is distributed on an 
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
+ * KIND, either express or implied. See the License for the 
+ * specific language governing permissions and limitations 
+ * under the License. 
+ */ 
+ 
+#include <sstream> 
+#include <string> 
+#include <fstream> 
+#include <iostream> 
+#include <vector> 
+#include <cctype> 
+ 
+#include <sys/stat.h> 
+#include <stdexcept> 
+ 
+#include "thrift/platform.h" 
+#include "thrift/generate/t_oop_generator.h" 
+ 
+using std::map; 
+using std::ostream; 
+using std::ostringstream; 
+using std::string; 
+using std::stringstream; 
+using std::vector; 
+ 
+static const string endl = "\n"; // avoid ostream << std::endl flushes 
+ 
+/** 
+ * AS3 code generator. 
+ * 
+ */ 
+class t_as3_generator : public t_oop_generator { 
+public: 
+  t_as3_generator(t_program* program, 
+                  const std::map<std::string, std::string>& parsed_options, 
+                  const std::string& option_string) 
+    : t_oop_generator(program) { 
+    (void)option_string; 
+    std::map<std::string, std::string>::const_iterator iter; 
+ 
+    bindable_ = false; 
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) { 
+      if( iter->first.compare("bindable") == 0) { 
+        bindable_ = true; 
+      } else { 
+        throw "unknown option as3:" + iter->first; 
+      } 
+    } 
+ 
+    out_dir_base_ = "gen-as3"; 
+  } 
+ 
+  /** 
+   * Init and close methods 
+   */ 
+ 
+  void init_generator(); 
+  void close_generator(); 
+ 
+  void generate_consts(std::vector<t_const*> consts); 
+ 
+  /** 
+   * Program-level generation functions 
+   */ 
+ 
+  void generate_typedef(t_typedef* ttypedef); 
+  void generate_enum(t_enum* tenum); 
+  void generate_struct(t_struct* tstruct); 
+  void generate_xception(t_struct* txception); 
+  void generate_service(t_service* tservice); 
+ 
+  void print_const_value(std::ostream& out, 
+                         std::string name, 
+                         t_type* type, 
+                         t_const_value* value, 
+                         bool in_static, 
+                         bool defval = false); 
+  std::string render_const_value(ostream& out, 
+                                 std::string name, 
+                                 t_type* type, 
+                                 t_const_value* value); 
+ 
+  /** 
+   * Service-level generation functions 
+   */ 
+ 
+  void generate_as3_struct(t_struct* tstruct, bool is_exception); 
+ 
+  void generate_as3_struct_definition(std::ostream& out, 
+                                      t_struct* tstruct, 
+                                      bool is_xception = false, 
+                                      bool in_class = false, 
+                                      bool is_result = false); 
+  // removed -- equality,compare_to 
+  void generate_as3_struct_reader(std::ostream& out, t_struct* tstruct); 
+  void generate_as3_validator(std::ostream& out, t_struct* tstruct); 
+  void generate_as3_struct_result_writer(std::ostream& out, t_struct* tstruct); 
+  void generate_as3_struct_writer(std::ostream& out, t_struct* tstruct); 
+  void generate_as3_struct_tostring(std::ostream& out, t_struct* tstruct, bool bindable); 
+  void generate_as3_meta_data_map(std::ostream& out, t_struct* tstruct); 
+  void generate_field_value_meta_data(std::ostream& out, t_type* type); 
+  std::string get_as3_type_string(t_type* type); 
+  void generate_reflection_setters(std::ostringstream& out, 
+                                   t_type* type, 
+                                   std::string field_name, 
+                                   std::string cap_name); 
+  void generate_reflection_getters(std::ostringstream& out, 
+                                   t_type* type, 
+                                   std::string field_name, 
+                                   std::string cap_name); 
+  void generate_generic_field_getters_setters(std::ostream& out, t_struct* tstruct); 
+  void generate_generic_isset_method(std::ostream& out, t_struct* tstruct); 
+  void generate_as3_bean_boilerplate(std::ostream& out, t_struct* tstruct, bool bindable); 
+ 
+  void generate_function_helpers(t_function* tfunction); 
+  std::string get_cap_name(std::string name); 
+  std::string generate_isset_check(t_field* field); 
+  std::string generate_isset_check(std::string field); 
+  void generate_isset_set(ostream& out, t_field* field); 
+  // removed std::string isset_field_id(t_field* field); 
+ 
+  void generate_service_interface(t_service* tservice); 
+  void generate_service_helpers(t_service* tservice); 
+  void generate_service_client(t_service* tservice); 
+  void generate_service_server(t_service* tservice); 
+  void generate_process_function(t_service* tservice, t_function* tfunction); 
+ 
+  /** 
+   * Serialization constructs 
+   */ 
+ 
+  void generate_deserialize_field(std::ostream& out, t_field* tfield, std::string prefix = ""); 
+ 
+  void generate_deserialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = ""); 
+ 
+  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+ 
+  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = ""); 
+ 
+  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = ""); 
+ 
+  void generate_deserialize_list_element(std::ostream& out, 
+                                         t_list* tlist, 
+                                         std::string prefix = ""); 
+ 
+  void generate_serialize_field(std::ostream& out, t_field* tfield, std::string prefix = ""); 
+ 
+  void generate_serialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = ""); 
+ 
+  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+ 
+  void generate_serialize_map_element(std::ostream& out, 
+                                      t_map* tmap, 
+                                      std::string iter, 
+                                      std::string map); 
+ 
+  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter); 
+ 
+  void generate_serialize_list_element(std::ostream& out, t_list* tlist, std::string iter); 
+ 
+  void generate_as3_doc(std::ostream& out, t_doc* tdoc); 
+ 
+  void generate_as3_doc(std::ostream& out, t_function* tdoc); 
+ 
+  /** 
+   * Helper rendering functions 
+   */ 
+ 
+  std::string as3_package(); 
+  std::string as3_type_imports(); 
+  std::string as3_thrift_imports(); 
+  std::string as3_thrift_gen_imports(t_struct* tstruct, string& imports); 
+  std::string as3_thrift_gen_imports(t_service* tservice); 
+  std::string type_name(t_type* ttype, bool in_container = false, bool in_init = false); 
+  std::string base_type_name(t_base_type* tbase, bool in_container = false); 
+  std::string declare_field(t_field* tfield, bool init = false); 
+  std::string function_signature(t_function* tfunction, std::string prefix = ""); 
+  std::string argument_list(t_struct* tstruct); 
+  std::string type_to_enum(t_type* ttype); 
+  std::string get_enum_class_name(t_type* type); 
+ 
+  bool type_can_be_null(t_type* ttype) { 
+    ttype = get_true_type(ttype); 
+ 
+    return ttype->is_container() || ttype->is_struct() || ttype->is_xception() 
+           || ttype->is_string(); 
+  } 
+ 
+  std::string constant_name(std::string name); 
+ 
+private: 
+  /** 
+   * File streams 
+   */ 
+ 
+  std::string package_name_; 
+  ofstream_with_content_based_conditional_update f_service_; 
+  std::string package_dir_; 
+ 
+  bool bindable_; 
+}; 
+ 
+/** 
+ * Prepares for file generation by opening up the necessary file output 
+ * streams. 
+ * 
+ * @param tprogram The program to generate 
+ */ 
+void t_as3_generator::init_generator() { 
+  // Make output directory 
+  MKDIR(get_out_dir().c_str()); 
+  package_name_ = program_->get_namespace("as3"); 
+ 
+  string dir = package_name_; 
+  string subdir = get_out_dir(); 
+  string::size_type loc; 
+  while ((loc = dir.find(".")) != string::npos) { 
+    subdir = subdir + "/" + dir.substr(0, loc); 
+    MKDIR(subdir.c_str()); 
+    dir = dir.substr(loc + 1); 
+  } 
+  if (dir.size() > 0) { 
+    subdir = subdir + "/" + dir; 
+    MKDIR(subdir.c_str()); 
+  } 
+ 
+  package_dir_ = subdir; 
+} 
+ 
+/** 
+ * Packages the generated file 
+ * 
+ * @return String of the package, i.e. "package org.apache.thriftdemo;" 
+ */ 
+string t_as3_generator::as3_package() { 
+  if (!package_name_.empty()) { 
+    return string("package ") + package_name_ + " "; 
+  } 
+  return "package "; 
+} 
+ 
+/** 
+ * Prints standard as3 imports 
+ * 
+ * @return List of imports for As3 types that are used in here 
+ */ 
+string t_as3_generator::as3_type_imports() { 
+  return string() + "import org.apache.thrift.Set;\n" + "import flash.utils.ByteArray;\n" 
+         + "import flash.utils.Dictionary;\n\n"; 
+} 
+ 
+/** 
+ * Prints standard as3 imports 
+ * 
+ * @return List of imports necessary for thrift 
+ */ 
+string t_as3_generator::as3_thrift_imports() { 
+  return string() + "import org.apache.thrift.*;\n" + "import org.apache.thrift.meta_data.*;\n" 
+         + "import org.apache.thrift.protocol.*;\n\n"; 
+} 
+ 
+/** 
+ * Prints imports needed for a given type 
+ * 
+ * @return List of imports necessary for a given t_struct 
+ */ 
+string t_as3_generator::as3_thrift_gen_imports(t_struct* tstruct, string& imports) { 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  // For each type check if it is from a differnet namespace 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_program* program = (*m_iter)->get_type()->get_program(); 
+    if (program != NULL && program != program_) { 
+      string package = program->get_namespace("as3"); 
+      if (!package.empty()) { 
+        if (imports.find(package + "." + (*m_iter)->get_type()->get_name()) == string::npos) { 
+          imports.append("import " + package + "." + (*m_iter)->get_type()->get_name() + ";\n"); 
+        } 
+      } 
+    } 
+  } 
+  return imports; 
+} 
+ 
+/** 
+ * Prints imports needed for a given type 
+ * 
+ * @return List of imports necessary for a given t_service 
+ */ 
+string t_as3_generator::as3_thrift_gen_imports(t_service* tservice) { 
+  string imports; 
+  const vector<t_function*>& functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+ 
+  // For each type check if it is from a differnet namespace 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    t_program* program = (*f_iter)->get_returntype()->get_program(); 
+    if (program != NULL && program != program_) { 
+      string package = program->get_namespace("as3"); 
+      if (!package.empty()) { 
+        if (imports.find(package + "." + (*f_iter)->get_returntype()->get_name()) == string::npos) { 
+          imports.append("import " + package + "." + (*f_iter)->get_returntype()->get_name() 
+                         + ";\n"); 
+        } 
+      } 
+    } 
+ 
+    as3_thrift_gen_imports((*f_iter)->get_arglist(), imports); 
+    as3_thrift_gen_imports((*f_iter)->get_xceptions(), imports); 
+  } 
+ 
+  return imports; 
+} 
+ 
+/** 
+ * Nothing in As3 
+ */ 
+void t_as3_generator::close_generator() { 
+} 
+ 
+/** 
+ * Generates a typedef. This is not done in As3, since it does 
+ * not support arbitrary name replacements, and it'd be a wacky waste 
+ * of overhead to make wrapper classes. 
+ * 
+ * @param ttypedef The type definition 
+ */ 
+void t_as3_generator::generate_typedef(t_typedef* ttypedef) { 
+  (void)ttypedef; 
+} 
+ 
+/** 
+ * Enums are a class with a set of static constants. 
+ * 
+ * @param tenum The enumeration 
+ */ 
+void t_as3_generator::generate_enum(t_enum* tenum) { 
+  // Make output file 
+  string f_enum_name = package_dir_ + "/" + (tenum->get_name()) + ".as"; 
+  ofstream_with_content_based_conditional_update f_enum; 
+  f_enum.open(f_enum_name); 
+ 
+  // Comment and package it 
+  f_enum << autogen_comment() << as3_package() << endl; 
+ 
+  scope_up(f_enum); 
+  // Add as3 imports 
+  f_enum << string() + "import org.apache.thrift.Set;" << endl << "import flash.utils.Dictionary;" 
+         << endl; 
+ 
+  indent(f_enum) << "public class " << tenum->get_name() << " "; 
+  scope_up(f_enum); 
+ 
+  vector<t_enum_value*> constants = tenum->get_constants(); 
+  vector<t_enum_value*>::iterator c_iter; 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    int value = (*c_iter)->get_value(); 
+    indent(f_enum) << "public static const " << (*c_iter)->get_name() << ":int = " << value << ";" 
+                   << endl; 
+  } 
+ 
+  // Create a static Set with all valid values for this enum 
+  f_enum << endl; 
+ 
+  indent(f_enum) << "public static const VALID_VALUES:Set = new Set("; 
+  indent_up(); 
+  bool firstValue = true; 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    // populate set 
+    f_enum << (firstValue ? "" : ", ") << (*c_iter)->get_name(); 
+    firstValue = false; 
+  } 
+  indent_down(); 
+  f_enum << ");" << endl; 
+ 
+  indent(f_enum) << "public static const VALUES_TO_NAMES:Dictionary = new Dictionary();" << endl; 
+ 
+  scope_up(f_enum); 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    indent(f_enum) << "VALUES_TO_NAMES[" << (*c_iter)->get_name() << "] = \"" 
+                   << (*c_iter)->get_name() << "\";" << endl; 
+  } 
+  f_enum << endl; 
+ 
+  scope_down(f_enum); 
+ 
+  scope_down(f_enum); // end class 
+ 
+  scope_down(f_enum); // end package 
+ 
+  f_enum.close(); 
+} 
+ 
+/** 
+ * Generates a class that holds all the constants. 
+ */ 
+void t_as3_generator::generate_consts(std::vector<t_const*> consts) { 
+  if (consts.empty()) { 
+    return; 
+  } 
+ 
+  string f_consts_name = package_dir_ + "/" + program_name_ + "Constants.as"; 
+  ofstream_with_content_based_conditional_update f_consts; 
+  f_consts.open(f_consts_name); 
+ 
+  // Print header 
+  f_consts << autogen_comment() << as3_package(); 
+ 
+  scope_up(f_consts); 
+  f_consts << endl; 
+ 
+  f_consts << as3_type_imports(); 
+ 
+  indent(f_consts) << "public class " << program_name_ << "Constants {" << endl << endl; 
+  indent_up(); 
+  vector<t_const*>::iterator c_iter; 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    print_const_value(f_consts, 
+                      (*c_iter)->get_name(), 
+                      (*c_iter)->get_type(), 
+                      (*c_iter)->get_value(), 
+                      false); 
+  } 
+  indent_down(); 
+  indent(f_consts) << "}" << endl; 
+  scope_down(f_consts); 
+  f_consts.close(); 
+} 
+ 
+void t_as3_generator::print_const_value(std::ostream& out, 
+                                        string name, 
+                                        t_type* type, 
+                                        t_const_value* value, 
+                                        bool in_static, 
+                                        bool defval) { 
+  type = get_true_type(type); 
+ 
+  indent(out); 
+  if (!defval) { 
+    out << (in_static ? "var " : "public static const "); 
+  } 
+  if (type->is_base_type()) { 
+    string v2 = render_const_value(out, name, type, value); 
+    out << name; 
+    if (!defval) { 
+      out << ":" << type_name(type); 
+    } 
+    out << " = " << v2 << ";" << endl << endl; 
+  } else if (type->is_enum()) { 
+    out << name; 
+    if (!defval) { 
+      out << ":" << type_name(type); 
+    } 
+    out << " = " << value->get_integer() << ";" << endl << endl; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    const vector<t_field*>& fields = ((t_struct*)type)->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    out << name << ":" << type_name(type) << " = new " << type_name(type, false, true) << "();" 
+        << endl; 
+    if (!in_static) { 
+      indent(out) << "{" << endl; 
+      indent_up(); 
+      indent(out) << "new function():void {" << endl; 
+      indent_up(); 
+    } 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      t_type* field_type = NULL; 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field_type = (*f_iter)->get_type(); 
+        } 
+      } 
+      if (field_type == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string(); 
+      } 
+      string val = render_const_value(out, name, field_type, v_iter->second); 
+      indent(out) << name << "."; 
+      out << v_iter->first->get_string() << " = " << val << ";" << endl; 
+    } 
+    if (!in_static) { 
+      indent_down(); 
+      indent(out) << "}();" << endl; 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+    out << endl; 
+  } else if (type->is_map()) { 
+    out << name; 
+    if (!defval) { 
+      out << ":" << type_name(type); 
+    } 
+    out << " = new " << type_name(type, false, true) << "();" << endl; 
+    if (!in_static) { 
+      indent(out) << "{" << endl; 
+      indent_up(); 
+      indent(out) << "new function():void {" << endl; 
+      indent_up(); 
+    } 
+    t_type* ktype = ((t_map*)type)->get_key_type(); 
+    t_type* vtype = ((t_map*)type)->get_val_type(); 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string key = render_const_value(out, name, ktype, v_iter->first); 
+      string val = render_const_value(out, name, vtype, v_iter->second); 
+      indent(out) << name << "[" << key << "] = " << val << ";" << endl; 
+    } 
+    if (!in_static) { 
+      indent_down(); 
+      indent(out) << "}();" << endl; 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+    out << endl; 
+  } else if (type->is_list() || type->is_set()) { 
+    out << name; 
+    if (!defval) { 
+      out << ":" << type_name(type); 
+    } 
+    out << " = new " << type_name(type, false, true) << "();" << endl; 
+    if (!in_static) { 
+      indent(out) << "{" << endl; 
+      indent_up(); 
+      indent(out) << "new function():void {" << endl; 
+      indent_up(); 
+    } 
+    t_type* etype; 
+    if (type->is_list()) { 
+      etype = ((t_list*)type)->get_elem_type(); 
+    } else { 
+      etype = ((t_set*)type)->get_elem_type(); 
+    } 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string val = render_const_value(out, name, etype, *v_iter); 
+      indent(out) << name << "." << (type->is_list() ? "push" : "add") << "(" << val << ");" 
+                  << endl; 
+    } 
+    if (!in_static) { 
+      indent_down(); 
+      indent(out) << "}();" << endl; 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+    out << endl; 
+  } else { 
+    throw "compiler error: no const of type " + type->get_name(); 
+  } 
+} 
+ 
+string t_as3_generator::render_const_value(ostream& out, 
+                                           string name, 
+                                           t_type* type, 
+                                           t_const_value* value) { 
+  (void)name; 
+  type = get_true_type(type); 
+  std::ostringstream render; 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      render << '"' << get_escaped_string(value) << '"'; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      render << ((value->get_integer() > 0) ? "true" : "false"); 
+      break; 
+    case t_base_type::TYPE_I8: 
+      render << "(byte)" << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_I16: 
+      render << "(short)" << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_I32: 
+      render << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_I64: 
+      render << value->get_integer() << "L"; 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      if (value->get_type() == t_const_value::CV_INTEGER) { 
+        render << "(double)" << value->get_integer(); 
+      } else { 
+        render << value->get_double(); 
+      } 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else if (type->is_enum()) { 
+    render << value->get_integer(); 
+  } else { 
+    string t = tmp("tmp"); 
+    print_const_value(out, t, type, value, true); 
+    render << t; 
+  } 
+ 
+  return render.str(); 
+} 
+ 
+/** 
+ * Generates a struct definition for a thrift data type. This is a class 
+ * with data members, read(), write(), and an inner Isset class. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_struct(t_struct* tstruct) { 
+  generate_as3_struct(tstruct, false); 
+} 
+ 
+/** 
+ * Exceptions are structs, but they inherit from Exception 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_xception(t_struct* txception) { 
+  generate_as3_struct(txception, true); 
+} 
+ 
+/** 
+ * As3 struct definition. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_as3_struct(t_struct* tstruct, bool is_exception) { 
+  // Make output file 
+  string f_struct_name = package_dir_ + "/" + (tstruct->get_name()) + ".as"; 
+  ofstream_with_content_based_conditional_update f_struct; 
+  f_struct.open(f_struct_name.c_str()); 
+ 
+  f_struct << autogen_comment() << as3_package(); 
+ 
+  scope_up(f_struct); 
+  f_struct << endl; 
+ 
+  string imports; 
+ 
+  f_struct << as3_type_imports() << as3_thrift_imports() << as3_thrift_gen_imports(tstruct, imports) 
+           << endl; 
+ 
+  if (bindable_ && !is_exception) { 
+    f_struct << "import flash.events.Event;" << endl << "import flash.events.EventDispatcher;" 
+             << endl << "import mx.events.PropertyChangeEvent;" << endl; 
+  } 
+ 
+  generate_as3_struct_definition(f_struct, tstruct, is_exception); 
+ 
+  scope_down(f_struct); // end of package 
+  f_struct.close(); 
+} 
+ 
+/** 
+ * As3 struct definition. This has various parameters, as it could be 
+ * generated standalone or inside another class as a helper. If it 
+ * is a helper than it is a static class. 
+ * 
+ * @param tstruct      The struct definition 
+ * @param is_exception Is this an exception? 
+ * @param in_class     If inside a class, needs to be static class 
+ * @param is_result    If this is a result it needs a different writer 
+ */ 
+void t_as3_generator::generate_as3_struct_definition(ostream& out, 
+                                                     t_struct* tstruct, 
+                                                     bool is_exception, 
+                                                     bool in_class, 
+                                                     bool is_result) { 
+  generate_as3_doc(out, tstruct); 
+ 
+  bool is_final = (tstruct->annotations_.find("final") != tstruct->annotations_.end()); 
+  bool bindable = !is_exception && !in_class && bindable_; 
+ 
+  indent(out) << (in_class ? "" : "public ") << (is_final ? "final " : "") << "class " 
+              << tstruct->get_name() << " "; 
+ 
+  if (is_exception) { 
+    out << "extends Error "; 
+  } else if (bindable) { 
+    out << "extends EventDispatcher "; 
+  } 
+  out << "implements TBase "; 
+ 
+  scope_up(out); 
+ 
+  indent(out) << "private static const STRUCT_DESC:TStruct = new TStruct(\"" << tstruct->get_name() 
+              << "\");" << endl; 
+ 
+  // Members are public for -as3, private for -as3bean 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    indent(out) << "private static const " << constant_name((*m_iter)->get_name()) 
+                << "_FIELD_DESC:TField = new TField(\"" << (*m_iter)->get_name() << "\", " 
+                << type_to_enum((*m_iter)->get_type()) << ", " << (*m_iter)->get_key() << ");" 
+                << endl; 
+  } 
+ 
+  out << endl; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    generate_as3_doc(out, *m_iter); 
+    indent(out) << "private var _" << (*m_iter)->get_name() + ":" + type_name((*m_iter)->get_type()) 
+                << ";" << endl; 
+ 
+    indent(out) << "public static const " << upcase_string((*m_iter)->get_name()) 
+                << ":int = " << (*m_iter)->get_key() << ";" << endl; 
+  } 
+ 
+  out << endl; 
+ 
+  // Inner Isset class 
+  if (members.size() > 0) { 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      if (!type_can_be_null((*m_iter)->get_type())) { 
+        indent(out) << "private var __isset_" << (*m_iter)->get_name() << ":Boolean = false;" 
+                    << endl; 
+      } 
+    } 
+  } 
+ 
+  out << endl; 
+ 
+  generate_as3_meta_data_map(out, tstruct); 
+ 
+  // Static initializer to populate global class to struct metadata map 
+  indent(out) << "{" << endl; 
+  indent_up(); 
+  indent(out) << "FieldMetaData.addStructMetaDataMap(" << type_name(tstruct) << ", metaDataMap);" 
+              << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  // Default constructor 
+  indent(out) << "public function " << tstruct->get_name() << "() {" << endl; 
+  indent_up(); 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    if ((*m_iter)->get_value() != NULL) { 
+      indent(out) << "this._" << (*m_iter)->get_name() << " = " 
+                  << (*m_iter)->get_value()->get_integer() << ";" << endl; 
+    } 
+  } 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  generate_as3_bean_boilerplate(out, tstruct, bindable); 
+  generate_generic_field_getters_setters(out, tstruct); 
+  generate_generic_isset_method(out, tstruct); 
+ 
+  generate_as3_struct_reader(out, tstruct); 
+  if (is_result) { 
+    generate_as3_struct_result_writer(out, tstruct); 
+  } else { 
+    generate_as3_struct_writer(out, tstruct); 
+  } 
+  generate_as3_struct_tostring(out, tstruct, bindable); 
+  generate_as3_validator(out, tstruct); 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+/** 
+ * Generates a function to read all the fields of the struct. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_as3_struct_reader(ostream& out, t_struct* tstruct) { 
+  out << indent() << "public function read(iprot:TProtocol):void {" << endl; 
+  indent_up(); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  // Declare stack tmp variables and read struct header 
+  out << indent() << "var field:TField;" << endl << indent() << "iprot.readStructBegin();" << endl; 
+ 
+  // Loop over reading in fields 
+  indent(out) << "while (true)" << endl; 
+  scope_up(out); 
+ 
+  // Read beginning field marker 
+  indent(out) << "field = iprot.readFieldBegin();" << endl; 
+ 
+  // Check for field STOP marker and break 
+  indent(out) << "if (field.type == TType.STOP) { " << endl; 
+  indent_up(); 
+  indent(out) << "break;" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+ 
+  // Switch statement on the field we are reading 
+  indent(out) << "switch (field.id)" << endl; 
+ 
+  scope_up(out); 
+ 
+  // Generate deserialization code for known cases 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    indent(out) << "case " << upcase_string((*f_iter)->get_name()) << ":" << endl; 
+    indent_up(); 
+    indent(out) << "if (field.type == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl; 
+    indent_up(); 
+ 
+    generate_deserialize_field(out, *f_iter, "this."); 
+    generate_isset_set(out, *f_iter); 
+    indent_down(); 
+    out << indent() << "} else { " << endl << indent() << "  TProtocolUtil.skip(iprot, field.type);" 
+        << endl << indent() << "}" << endl << indent() << "break;" << endl; 
+    indent_down(); 
+  } 
+ 
+  // In the default case we skip the field 
+  out << indent() << "default:" << endl << indent() << "  TProtocolUtil.skip(iprot, field.type);" 
+      << endl << indent() << "  break;" << endl; 
+ 
+  scope_down(out); 
+ 
+  // Read field end marker 
+  indent(out) << "iprot.readFieldEnd();" << endl; 
+ 
+  scope_down(out); 
+ 
+  out << indent() << "iprot.readStructEnd();" << endl << endl; 
+ 
+  // in non-beans style, check for required fields of primitive type 
+  // (which can be checked here but not in the general validate method) 
+  out << endl << indent() << "// check for required fields of primitive type, which can't be " 
+                             "checked in the validate method" << endl; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() == t_field::T_REQUIRED && !type_can_be_null((*f_iter)->get_type())) { 
+      out << indent() << "if (!__isset_" << (*f_iter)->get_name() << ") {" << endl << indent() 
+          << "  throw new TProtocolError(TProtocolError.UNKNOWN, \"Required field '" 
+          << (*f_iter)->get_name() 
+          << "' was not found in serialized data! Struct: \" + toString());" << endl << indent() 
+          << "}" << endl; 
+    } 
+  } 
+ 
+  // performs various checks (e.g. check that all required fields are set) 
+  indent(out) << "validate();" << endl; 
+ 
+  indent_down(); 
+  out << indent() << "}" << endl << endl; 
+} 
+ 
+// generates as3 method to perform various checks 
+// (e.g. check that all required fields are set) 
+void t_as3_generator::generate_as3_validator(ostream& out, t_struct* tstruct) { 
+  indent(out) << "public function validate():void {" << endl; 
+  indent_up(); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  out << indent() << "// check for required fields" << endl; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() == t_field::T_REQUIRED) { 
+      if (type_can_be_null((*f_iter)->get_type())) { 
+        indent(out) << "if (" << (*f_iter)->get_name() << " == null) {" << endl; 
+        indent(out) << "  throw new TProtocolError(TProtocolError.UNKNOWN, \"Required field '" 
+                    << (*f_iter)->get_name() << "' was not present! Struct: \" + toString());" 
+                    << endl; 
+        indent(out) << "}" << endl; 
+      } else { 
+        indent(out) << "// alas, we cannot check '" << (*f_iter)->get_name() 
+                    << "' because it's a primitive and you chose the non-beans generator." << endl; 
+      } 
+    } 
+  } 
+ 
+  // check that fields of type enum have valid values 
+  out << indent() << "// check that fields of type enum have valid values" << endl; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_field* field = (*f_iter); 
+    t_type* type = field->get_type(); 
+    // if field is an enum, check that its value is valid 
+    if (type->is_enum()) { 
+      indent(out) << "if (" << generate_isset_check(field) << " && !" << get_enum_class_name(type) 
+                  << ".VALID_VALUES.contains(" << field->get_name() << ")){" << endl; 
+      indent_up(); 
+      indent(out) << "throw new TProtocolError(TProtocolError.UNKNOWN, \"The field '" 
+                  << field->get_name() << "' has been assigned the invalid value \" + " 
+                  << field->get_name() << ");" << endl; 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+  } 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a function to write all the fields of the struct 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_as3_struct_writer(ostream& out, t_struct* tstruct) { 
+  out << indent() << "public function write(oprot:TProtocol):void {" << endl; 
+  indent_up(); 
+ 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_sorted_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  // performs various checks (e.g. check that all required fields are set) 
+  indent(out) << "validate();" << endl << endl; 
+ 
+  indent(out) << "oprot.writeStructBegin(STRUCT_DESC);" << endl; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    bool could_be_unset = (*f_iter)->get_req() == t_field::T_OPTIONAL; 
+    if (could_be_unset) { 
+      indent(out) << "if (" << generate_isset_check(*f_iter) << ") {" << endl; 
+      indent_up(); 
+    } 
+    bool null_allowed = type_can_be_null((*f_iter)->get_type()); 
+    if (null_allowed) { 
+      out << indent() << "if (this." << (*f_iter)->get_name() << " != null) {" << endl; 
+      indent_up(); 
+    } 
+ 
+    indent(out) << "oprot.writeFieldBegin(" << constant_name((*f_iter)->get_name()) 
+                << "_FIELD_DESC);" << endl; 
+ 
+    // Write field contents 
+    generate_serialize_field(out, *f_iter, "this."); 
+ 
+    // Write field closer 
+    indent(out) << "oprot.writeFieldEnd();" << endl; 
+ 
+    if (null_allowed) { 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+    if (could_be_unset) { 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+  } 
+  // Write the struct map 
+  out << indent() << "oprot.writeFieldStop();" << endl << indent() << "oprot.writeStructEnd();" 
+      << endl; 
+ 
+  indent_down(); 
+  out << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a function to write all the fields of the struct, 
+ * which is a function result. These fields are only written 
+ * if they are set in the Isset array, and only one of them 
+ * can be set at a time. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_as3_struct_result_writer(ostream& out, t_struct* tstruct) { 
+  out << indent() << "public function write(oprot:TProtocol):void {" << endl; 
+  indent_up(); 
+ 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_sorted_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  indent(out) << "oprot.writeStructBegin(STRUCT_DESC);" << endl; 
+ 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+      out << endl << indent() << "if "; 
+    } else { 
+      out << " else if "; 
+    } 
+ 
+    out << "(this." << generate_isset_check(*f_iter) << ") {" << endl; 
+ 
+    indent_up(); 
+ 
+    indent(out) << "oprot.writeFieldBegin(" << constant_name((*f_iter)->get_name()) 
+                << "_FIELD_DESC);" << endl; 
+ 
+    // Write field contents 
+    generate_serialize_field(out, *f_iter, "this."); 
+ 
+    // Write field closer 
+    indent(out) << "oprot.writeFieldEnd();" << endl; 
+ 
+    indent_down(); 
+    indent(out) << "}"; 
+  } 
+  // Write the struct map 
+  out << endl << indent() << "oprot.writeFieldStop();" << endl << indent() 
+      << "oprot.writeStructEnd();" << endl; 
+ 
+  indent_down(); 
+  out << indent() << "}" << endl << endl; 
+} 
+ 
+void t_as3_generator::generate_reflection_getters(ostringstream& out, 
+                                                  t_type* type, 
+                                                  string field_name, 
+                                                  string cap_name) { 
+  (void)type; 
+  (void)cap_name; 
+  indent(out) << "case " << upcase_string(field_name) << ":" << endl; 
+  indent_up(); 
+  indent(out) << "return this." << field_name << ";" << endl; 
+  indent_down(); 
+} 
+ 
+void t_as3_generator::generate_reflection_setters(ostringstream& out, 
+                                                  t_type* type, 
+                                                  string field_name, 
+                                                  string cap_name) { 
+  (void)type; 
+  (void)cap_name; 
+  indent(out) << "case " << upcase_string(field_name) << ":" << endl; 
+  indent_up(); 
+  indent(out) << "if (value == null) {" << endl; 
+  indent(out) << "  unset" << get_cap_name(field_name) << "();" << endl; 
+  indent(out) << "} else {" << endl; 
+  indent(out) << "  this." << field_name << " = value;" << endl; 
+  indent(out) << "}" << endl; 
+  indent(out) << "break;" << endl << endl; 
+ 
+  indent_down(); 
+} 
+ 
+void t_as3_generator::generate_generic_field_getters_setters(std::ostream& out, 
+                                                             t_struct* tstruct) { 
+ 
+  std::ostringstream getter_stream; 
+  std::ostringstream setter_stream; 
+ 
+  // build up the bodies of both the getter and setter at once 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_field* field = *f_iter; 
+    t_type* type = get_true_type(field->get_type()); 
+    std::string field_name = field->get_name(); 
+    std::string cap_name = get_cap_name(field_name); 
+ 
+    indent_up(); 
+    generate_reflection_setters(setter_stream, type, field_name, cap_name); 
+    generate_reflection_getters(getter_stream, type, field_name, cap_name); 
+    indent_down(); 
+  } 
+ 
+  // create the setter 
+  indent(out) << "public function setFieldValue(fieldID:int, value:*):void {" << endl; 
+  indent_up(); 
+ 
+  indent(out) << "switch (fieldID) {" << endl; 
+ 
+  out << setter_stream.str(); 
+ 
+  indent(out) << "default:" << endl; 
+  indent(out) << "  throw new ArgumentError(\"Field \" + fieldID + \" doesn't exist!\");" << endl; 
+ 
+  indent(out) << "}" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  // create the getter 
+  indent(out) << "public function getFieldValue(fieldID:int):* {" << endl; 
+  indent_up(); 
+ 
+  indent(out) << "switch (fieldID) {" << endl; 
+ 
+  out << getter_stream.str(); 
+ 
+  indent(out) << "default:" << endl; 
+  indent(out) << "  throw new ArgumentError(\"Field \" + fieldID + \" doesn't exist!\");" << endl; 
+ 
+  indent(out) << "}" << endl; 
+ 
+  indent_down(); 
+ 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+// Creates a generic isSet method that takes the field number as argument 
+void t_as3_generator::generate_generic_isset_method(std::ostream& out, t_struct* tstruct) { 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  // create the isSet method 
+  indent(out) << "// Returns true if field corresponding to fieldID is set (has been assigned a " 
+                 "value) and false otherwise" << endl; 
+  indent(out) << "public function isSet(fieldID:int):Boolean {" << endl; 
+  indent_up(); 
+  indent(out) << "switch (fieldID) {" << endl; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_field* field = *f_iter; 
+    indent(out) << "case " << upcase_string(field->get_name()) << ":" << endl; 
+    indent_up(); 
+    indent(out) << "return " << generate_isset_check(field) << ";" << endl; 
+    indent_down(); 
+  } 
+ 
+  indent(out) << "default:" << endl; 
+  indent(out) << "  throw new ArgumentError(\"Field \" + fieldID + \" doesn't exist!\");" << endl; 
+ 
+  indent(out) << "}" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a set of As3 Bean boilerplate functions (setters, getters, etc.) 
+ * for the given struct. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_as3_bean_boilerplate(ostream& out, 
+                                                    t_struct* tstruct, 
+                                                    bool bindable) { 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_field* field = *f_iter; 
+    t_type* type = get_true_type(field->get_type()); 
+    std::string field_name = field->get_name(); 
+    std::string cap_name = get_cap_name(field_name); 
+ 
+    // Simple getter 
+    generate_as3_doc(out, field); 
+    indent(out) << "public function get " << field_name << "():" << type_name(type) << " {" << endl; 
+    indent_up(); 
+    indent(out) << "return this._" << field_name << ";" << endl; 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+ 
+    // Simple setter 
+    generate_as3_doc(out, field); 
+    std::string propName = tmp("thriftPropertyChange"); 
+    if (bindable) { 
+      indent(out) << "[Bindable(event=\"" << propName << "\")]" << endl; 
+    } 
+    indent(out) << "public function set " << field_name << "(" << field_name << ":" 
+                << type_name(type) << "):void {" << endl; 
+    indent_up(); 
+    indent(out) << "this._" << field_name << " = " << field_name << ";" << endl; 
+    generate_isset_set(out, field); 
+ 
+    if (bindable) { 
+      // We have to use a custom event rather than the default, because if you use the default, 
+      // the setter only gets called if the value has changed - this means calling 
+      // foo.setIntValue(0) 
+      // will not cause foo.isIntValueSet() to return true since the value of foo._intValue wasn't 
+      // changed 
+      // so the setter was never called. 
+      indent(out) << "dispatchEvent(new Event(\"" << propName << "\"));" << endl; 
+ 
+      // However, if you just use a custom event, then collections won't be able to detect when 
+      // elements 
+      // in the collections have changed since they listed for PropertyChangeEvents.  So, we 
+      // dispatch both. 
+      indent(out) << "dispatchEvent(new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE));" 
+                  << endl; 
+    } 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+ 
+    // Unsetter 
+    indent(out) << "public function unset" << cap_name << "():void {" << endl; 
+    indent_up(); 
+    if (type_can_be_null(type)) { 
+      indent(out) << "this." << field_name << " = null;" << endl; 
+    } else { 
+      indent(out) << "this.__isset_" << field_name << " = false;" << endl; 
+    } 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+ 
+    // isSet method 
+    indent(out) << "// Returns true if field " << field_name 
+                << " is set (has been assigned a value) and false otherwise" << endl; 
+    indent(out) << "public function is" << get_cap_name("set") << cap_name << "():Boolean {" 
+                << endl; 
+    indent_up(); 
+    if (type_can_be_null(type)) { 
+      indent(out) << "return this." << field_name << " != null;" << endl; 
+    } else { 
+      indent(out) << "return this.__isset_" << field_name << ";" << endl; 
+    } 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+  } 
+} 
+ 
+/** 
+ * Generates a toString() method for the given struct 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_as3_struct_tostring(ostream& out, 
+                                                   t_struct* tstruct, 
+                                                   bool bindable) { 
+  // If it's bindable, it extends EventDispatcher so toString is an override. 
+  out << indent() << "public " << (bindable ? "override " : "") << "function toString():String {" 
+      << endl; 
+  indent_up(); 
+ 
+  out << indent() << "var ret:String = new String(\"" << tstruct->get_name() << "(\");" << endl; 
+  out << indent() << "var first:Boolean = true;" << endl << endl; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    bool could_be_unset = (*f_iter)->get_req() == t_field::T_OPTIONAL; 
+    if (could_be_unset) { 
+      indent(out) << "if (" << generate_isset_check(*f_iter) << ") {" << endl; 
+      indent_up(); 
+    } 
+ 
+    t_field* field = (*f_iter); 
+ 
+    if (!first) { 
+      indent(out) << "if (!first) ret +=  \", \";" << endl; 
+    } 
+    indent(out) << "ret += \"" << (*f_iter)->get_name() << ":\";" << endl; 
+    bool can_be_null = type_can_be_null(field->get_type()); 
+    if (can_be_null) { 
+      indent(out) << "if (this." << (*f_iter)->get_name() << " == null) {" << endl; 
+      indent(out) << "  ret += \"null\";" << endl; 
+      indent(out) << "} else {" << endl; 
+      indent_up(); 
+    } 
+ 
+    if (field->get_type()->is_binary()) { 
+      indent(out) << "  ret += \"BINARY\";" << endl; 
+    } else if (field->get_type()->is_enum()) { 
+      indent(out) << "var " << field->get_name() 
+                  << "_name:String = " << get_enum_class_name(field->get_type()) 
+                  << ".VALUES_TO_NAMES[this." << (*f_iter)->get_name() << "];" << endl; 
+      indent(out) << "if (" << field->get_name() << "_name != null) {" << endl; 
+      indent(out) << "  ret += " << field->get_name() << "_name;" << endl; 
+      indent(out) << "  ret += \" (\";" << endl; 
+      indent(out) << "}" << endl; 
+      indent(out) << "ret += this." << field->get_name() << ";" << endl; 
+      indent(out) << "if (" << field->get_name() << "_name != null) {" << endl; 
+      indent(out) << "  ret += \")\";" << endl; 
+      indent(out) << "}" << endl; 
+    } else { 
+      indent(out) << "ret += this." << (*f_iter)->get_name() << ";" << endl; 
+    } 
+ 
+    if (can_be_null) { 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+    indent(out) << "first = false;" << endl; 
+ 
+    if (could_be_unset) { 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+    first = false; 
+  } 
+  out << indent() << "ret += \")\";" << endl << indent() << "return ret;" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a static map with meta data to store information such as fieldID to 
+ * fieldName mapping 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_as3_generator::generate_as3_meta_data_map(ostream& out, t_struct* tstruct) { 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  // Static Map with fieldID -> FieldMetaData mappings 
+  indent(out) << "public static const metaDataMap:Dictionary = new Dictionary();" << endl; 
+ 
+  if (fields.size() > 0) { 
+    // Populate map 
+    scope_up(out); 
+    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+      t_field* field = *f_iter; 
+      std::string field_name = field->get_name(); 
+      indent(out) << "metaDataMap[" << upcase_string(field_name) << "] = new FieldMetaData(\"" 
+                  << field_name << "\", "; 
+ 
+      // Set field requirement type (required, optional, etc.) 
+      if (field->get_req() == t_field::T_REQUIRED) { 
+        out << "TFieldRequirementType.REQUIRED, "; 
+      } else if (field->get_req() == t_field::T_OPTIONAL) { 
+        out << "TFieldRequirementType.OPTIONAL, "; 
+      } else { 
+        out << "TFieldRequirementType.DEFAULT, "; 
+      } 
+ 
+      // Create value meta data 
+      generate_field_value_meta_data(out, field->get_type()); 
+      out << ");" << endl; 
+    } 
+    scope_down(out); 
+  } 
+} 
+ 
+/** 
+ * Returns a string with the as3 representation of the given thrift type 
+ * (e.g. for the type struct it returns "TType.STRUCT") 
+ */ 
+std::string t_as3_generator::get_as3_type_string(t_type* type) { 
+  if (type->is_list()) { 
+    return "TType.LIST"; 
+  } else if (type->is_map()) { 
+    return "TType.MAP"; 
+  } else if (type->is_set()) { 
+    return "TType.SET"; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    return "TType.STRUCT"; 
+  } else if (type->is_enum()) { 
+    return "TType.I32"; 
+  } else if (type->is_typedef()) { 
+    return get_as3_type_string(((t_typedef*)type)->get_type()); 
+  } else if (type->is_base_type()) { 
+    switch (((t_base_type*)type)->get_base()) { 
+    case t_base_type::TYPE_VOID: 
+      return "TType.VOID"; 
+      break; 
+    case t_base_type::TYPE_STRING: 
+      return "TType.STRING"; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      return "TType.BOOL"; 
+      break; 
+    case t_base_type::TYPE_I8: 
+      return "TType.BYTE"; 
+      break; 
+    case t_base_type::TYPE_I16: 
+      return "TType.I16"; 
+      break; 
+    case t_base_type::TYPE_I32: 
+      return "TType.I32"; 
+      break; 
+    case t_base_type::TYPE_I64: 
+      return "TType.I64"; 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "TType.DOUBLE"; 
+      break; 
+    default: 
+      throw std::runtime_error("Unknown thrift type \"" + type->get_name() 
+                               + "\" passed to t_as3_generator::get_as3_type_string!"); 
+      break; // This should never happen! 
+    } 
+  } else { 
+    throw std::runtime_error( 
+        "Unknown thrift type \"" + type->get_name() 
+        + "\" passed to t_as3_generator::get_as3_type_string!"); // This should never happen! 
+  } 
+} 
+ 
+void t_as3_generator::generate_field_value_meta_data(std::ostream& out, t_type* type) { 
+  out << endl; 
+  indent_up(); 
+  indent_up(); 
+  if (type->is_struct() || type->is_xception()) { 
+    indent(out) << "new StructMetaData(TType.STRUCT, " << type_name(type); 
+  } else if (type->is_container()) { 
+    if (type->is_list()) { 
+      indent(out) << "new ListMetaData(TType.LIST, "; 
+      t_type* elem_type = ((t_list*)type)->get_elem_type(); 
+      generate_field_value_meta_data(out, elem_type); 
+    } else if (type->is_set()) { 
+      indent(out) << "new SetMetaData(TType.SET, "; 
+      t_type* elem_type = ((t_list*)type)->get_elem_type(); 
+      generate_field_value_meta_data(out, elem_type); 
+    } else { // map 
+      indent(out) << "new MapMetaData(TType.MAP, "; 
+      t_type* key_type = ((t_map*)type)->get_key_type(); 
+      t_type* val_type = ((t_map*)type)->get_val_type(); 
+      generate_field_value_meta_data(out, key_type); 
+      out << ", "; 
+      generate_field_value_meta_data(out, val_type); 
+    } 
+  } else { 
+    indent(out) << "new FieldValueMetaData(" << get_as3_type_string(type); 
+  } 
+  out << ")"; 
+  indent_down(); 
+  indent_down(); 
+} 
+ 
+/** 
+ * Generates a thrift service. In C++, this comprises an entirely separate 
+ * header and source file. The header file defines the methods and includes 
+ * the data types defined in the main header file, and the implementation 
+ * file contains implementations of the basic printer and default interfaces. 
+ * 
+ * @param tservice The service definition 
+ */ 
+void t_as3_generator::generate_service(t_service* tservice) { 
+  // Make interface file 
+  string f_service_name = package_dir_ + "/" + service_name_ + ".as"; 
+  f_service_.open(f_service_name.c_str()); 
+ 
+  f_service_ << autogen_comment() << as3_package(); 
+ 
+  scope_up(f_service_); 
+ 
+  f_service_ << endl << as3_type_imports() << as3_thrift_imports() 
+             << as3_thrift_gen_imports(tservice); 
+ 
+  if (tservice->get_extends() != NULL) { 
+    t_type* parent = tservice->get_extends(); 
+    string parent_namespace = parent->get_program()->get_namespace("as3"); 
+    if (!parent_namespace.empty() && parent_namespace != package_name_) { 
+      f_service_ << "import " << type_name(parent) << ";" << endl; 
+    } 
+  } 
+ 
+  f_service_ << endl; 
+ 
+  generate_service_interface(tservice); 
+ 
+  scope_down(f_service_); 
+  f_service_.close(); 
+ 
+  // Now make the implementation/client file 
+  f_service_name = package_dir_ + "/" + service_name_ + "Impl.as"; 
+  f_service_.open(f_service_name.c_str()); 
+ 
+  f_service_ << autogen_comment() << as3_package(); 
+ 
+  scope_up(f_service_); 
+ 
+  f_service_ << endl << as3_type_imports() << as3_thrift_imports() 
+             << as3_thrift_gen_imports(tservice); 
+ 
+  if (tservice->get_extends() != NULL) { 
+    t_type* parent = tservice->get_extends(); 
+    string parent_namespace = parent->get_program()->get_namespace("as3"); 
+    if (!parent_namespace.empty() && parent_namespace != package_name_) { 
+      f_service_ << "import " << type_name(parent) << "Impl;" << endl; 
+    } 
+  } 
+ 
+  f_service_ << endl; 
+ 
+  generate_service_client(tservice); 
+  scope_down(f_service_); 
+ 
+  f_service_ << as3_type_imports(); 
+  f_service_ << as3_thrift_imports(); 
+  f_service_ << as3_thrift_gen_imports(tservice); 
+  if (!package_name_.empty()) { 
+    f_service_ << "import " << package_name_ << ".*;" << endl; 
+  } 
+ 
+  generate_service_helpers(tservice); 
+ 
+  f_service_.close(); 
+ 
+  // Now make the processor/server file 
+  f_service_name = package_dir_ + "/" + service_name_ + "Processor.as"; 
+  f_service_.open(f_service_name.c_str()); 
+ 
+  f_service_ << autogen_comment() << as3_package(); 
+ 
+  scope_up(f_service_); 
+ 
+  f_service_ << endl << as3_type_imports() << as3_thrift_imports() 
+             << as3_thrift_gen_imports(tservice) << endl; 
+ 
+  generate_service_server(tservice); 
+  scope_down(f_service_); 
+ 
+  f_service_ << as3_type_imports(); 
+  f_service_ << as3_thrift_imports(); 
+  f_service_ << as3_thrift_gen_imports(tservice) << endl; 
+  if (!package_name_.empty()) { 
+    f_service_ << "import " << package_name_ << ".*;" << endl; 
+  } 
+ 
+  generate_service_helpers(tservice); 
+ 
+  f_service_.close(); 
+} 
+ 
+/** 
+ * Generates a service interface definition. 
+ * 
+ * @param tservice The service to generate a header definition for 
+ */ 
+void t_as3_generator::generate_service_interface(t_service* tservice) { 
+  string extends_iface = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends_iface = " extends " + tservice->get_extends()->get_name(); 
+  } 
+ 
+  generate_as3_doc(f_service_, tservice); 
+  f_service_ << indent() << "public interface " << service_name_ << extends_iface << " {" << endl 
+             << endl; 
+  indent_up(); 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_as3_doc(f_service_, *f_iter); 
+    if (!(*f_iter)->is_oneway()) { 
+      if ((*f_iter)->get_returntype()->is_void()) { 
+        indent(f_service_) << "//function onError(Error):void;" << endl; 
+        indent(f_service_) << "//function onSuccess():void;" << endl; 
+      } else { 
+        indent(f_service_) << "//function onError(Error):void;" << endl; 
+        indent(f_service_) << "//function onSuccess(" << type_name((*f_iter)->get_returntype()) 
+                           << "):void;" << endl; 
+      } 
+    } 
+    indent(f_service_) << function_signature(*f_iter) << ";" << endl << endl; 
+  } 
+  indent_down(); 
+  f_service_ << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates structs for all the service args and return types 
+ * 
+ * @param tservice The service 
+ */ 
+void t_as3_generator::generate_service_helpers(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    t_struct* ts = (*f_iter)->get_arglist(); 
+    generate_as3_struct_definition(f_service_, ts, false, true); 
+    generate_function_helpers(*f_iter); 
+  } 
+} 
+ 
+/** 
+ * Generates a service client definition. 
+ * 
+ * @param tservice The service to generate a server for. 
+ */ 
+void t_as3_generator::generate_service_client(t_service* tservice) { 
+  string extends = ""; 
+  string extends_client = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = tservice->get_extends()->get_name(); 
+    extends_client = " extends " + extends + "Impl"; 
+  } 
+ 
+  indent(f_service_) << "public class " << service_name_ << "Impl" << extends_client 
+                     << " implements " << service_name_ << " {" << endl; 
+  indent_up(); 
+ 
+  indent(f_service_) << "public function " << service_name_ << "Impl" 
+                     << "(iprot:TProtocol, oprot:TProtocol=null)" << endl; 
+  scope_up(f_service_); 
+  if (extends.empty()) { 
+    f_service_ << indent() << "iprot_ = iprot;" << endl; 
+    f_service_ << indent() << "if (oprot == null) {" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "oprot_ = iprot;" << endl; 
+    indent_down(); 
+    f_service_ << indent() << "} else {" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "oprot_ = oprot;" << endl; 
+    indent_down(); 
+    f_service_ << indent() << "}"; 
+  } else { 
+    f_service_ << indent() << "super(iprot, oprot);" << endl; 
+  } 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  if (extends.empty()) { 
+    f_service_ << indent() << "protected var iprot_:TProtocol;" << endl << indent() 
+               << "protected var oprot_:TProtocol;" << endl << endl << indent() 
+               << "protected var seqid_:int;" << endl << endl; 
+ 
+    indent(f_service_) << "public function getInputProtocol():TProtocol" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "return this.iprot_;" << endl; 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+ 
+    indent(f_service_) << "public function getOutputProtocol():TProtocol" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "return this.oprot_;" << endl; 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+  } 
+ 
+  // Generate client method implementations 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    string funname = (*f_iter)->get_name(); 
+ 
+    // Open function 
+    if (!(*f_iter)->is_oneway()) { 
+      if ((*f_iter)->get_returntype()->is_void()) { 
+        indent(f_service_) << "//function onError(Error):void;" << endl; 
+        indent(f_service_) << "//function onSuccess():void;" << endl; 
+      } else { 
+        indent(f_service_) << "//function onError(Error):void;" << endl; 
+        indent(f_service_) << "//function onSuccess(" << type_name((*f_iter)->get_returntype()) 
+                           << "):void;" << endl; 
+      } 
+    } 
+    indent(f_service_) << "public " << function_signature(*f_iter) << endl; 
+    scope_up(f_service_); 
+ 
+    // Get the struct of function call params 
+    t_struct* arg_struct = (*f_iter)->get_arglist(); 
+ 
+    string argsname = (*f_iter)->get_name() + "_args"; 
+    vector<t_field*>::const_iterator fld_iter; 
+    const vector<t_field*>& fields = arg_struct->get_members(); 
+ 
+    // Serialize the request 
+    f_service_ << indent() << "oprot_.writeMessageBegin(new TMessage(\"" << funname << "\", " 
+               << ((*f_iter)->is_oneway() ? "TMessageType.ONEWAY" : "TMessageType.CALL") 
+               << ", seqid_));" << endl << indent() << "var args:" << argsname << " = new " 
+               << argsname << "();" << endl; 
+ 
+    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+      f_service_ << indent() << "args." << (*fld_iter)->get_name() << " = " 
+                 << (*fld_iter)->get_name() << ";" << endl; 
+    } 
+ 
+    f_service_ << indent() << "args.write(oprot_);" << endl << indent() 
+               << "oprot_.writeMessageEnd();" << endl; 
+ 
+    if ((*f_iter)->is_oneway()) { 
+      f_service_ << indent() << "oprot_.getTransport().flush();" << endl; 
+    } else { 
+      f_service_ << indent() << "oprot_.getTransport().flush(function(error:Error):void {" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "try {" << endl; 
+      indent_up(); 
+      string resultname = (*f_iter)->get_name() + "_result"; 
+      f_service_ << indent() << "if (error != null) {" << endl << indent() 
+                 << "  if (onError != null) onError(error);" << endl << indent() << "  return;" 
+                 << endl << indent() << "}" << endl << indent() 
+                 << "var msg:TMessage = iprot_.readMessageBegin();" << endl << indent() 
+                 << "if (msg.type == TMessageType.EXCEPTION) {" << endl << indent() 
+                 << "  var x:TApplicationError = TApplicationError.read(iprot_);" << endl 
+                 << indent() << "  iprot_.readMessageEnd();" << endl << indent() 
+                 << "  if (onError != null) onError(x);" << endl << indent() << "  return;" << endl 
+                 << indent() << "}" << endl << indent() << "var result :" << resultname << " = new " 
+                 << resultname << "();" << endl << indent() << "result.read(iprot_);" << endl 
+                 << indent() << "iprot_.readMessageEnd();" << endl; 
+ 
+      // Careful, only return _result if not a void function 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        f_service_ << indent() << "if (result." << generate_isset_check("success") << ") {" << endl 
+                   << indent() << "  if (onSuccess != null) onSuccess(result.success);" << endl 
+                   << indent() << "  return;" << endl << indent() << "}" << endl; 
+      } 
+ 
+      t_struct* xs = (*f_iter)->get_xceptions(); 
+      const std::vector<t_field*>& xceptions = xs->get_members(); 
+      vector<t_field*>::const_iterator x_iter; 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+        f_service_ << indent() << "if (result." << (*x_iter)->get_name() << " != null) {" << endl 
+                   << indent() << "  if (onError != null) onError(result." << (*x_iter)->get_name() 
+                   << ");" << endl << indent() << "  return;" << endl << indent() << "}" << endl; 
+      } 
+ 
+      // If you get here it's an exception, unless a void function 
+      if ((*f_iter)->get_returntype()->is_void()) { 
+        f_service_ << indent() << "if (onSuccess != null) onSuccess();" << endl << indent() 
+                   << "return;" << endl; 
+      } else { 
+ 
+        f_service_ << indent() << "if (onError != null) onError(new " 
+                                  "TApplicationError(TApplicationError.MISSING_RESULT, \"" 
+                   << (*f_iter)->get_name() << " failed: unknown result\"));" << endl; 
+      } 
+      indent_down(); 
+      f_service_ << indent() << "} catch (e:TError) {" << endl << indent() 
+                 << "  if (onError != null) onError(e);" << endl << indent() << "}" << endl; 
+ 
+      indent_down(); 
+      indent(f_service_) << "});" << endl; 
+    } 
+    // Close function 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+  } 
+ 
+  indent_down(); 
+  indent(f_service_) << "}" << endl; 
+} 
+ 
+/** 
+ * Generates a service server definition. 
+ * 
+ * @param tservice The service to generate a server for. 
+ */ 
+void t_as3_generator::generate_service_server(t_service* tservice) { 
+  // Generate the dispatch methods 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+ 
+  // Extends stuff 
+  string extends = ""; 
+  string extends_processor = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = type_name(tservice->get_extends()); 
+    extends_processor = " extends " + extends + "Processor"; 
+  } 
+ 
+  // Generate the header portion 
+  indent(f_service_) << "public class " << service_name_ << "Processor" << extends_processor 
+                     << " implements TProcessor {" << endl; 
+  indent_up(); 
+ 
+  indent(f_service_) << "public function " << service_name_ << "Processor(iface:" << service_name_ 
+                     << ")" << endl; 
+  scope_up(f_service_); 
+  if (!extends.empty()) { 
+    f_service_ << indent() << "super(iface);" << endl; 
+  } 
+  f_service_ << indent() << "iface_ = iface;" << endl; 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    f_service_ << indent() << "PROCESS_MAP[\"" << (*f_iter)->get_name() 
+               << "\"] = " << (*f_iter)->get_name() << "();" << endl; 
+  } 
+ 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  f_service_ << indent() << "private var iface_:" << service_name_ << ";" << endl; 
+ 
+  if (extends.empty()) { 
+    f_service_ << indent() << "protected const PROCESS_MAP:Dictionary = new Dictionary();" << endl; 
+  } 
+ 
+  f_service_ << endl; 
+ 
+  // Generate the server implementation 
+  string override = ""; 
+  if (tservice->get_extends() != NULL) { 
+    override = "override "; 
+  } 
+  indent(f_service_) << override 
+                     << "public function process(iprot:TProtocol, oprot:TProtocol):Boolean" << endl; 
+  scope_up(f_service_); 
+ 
+  f_service_ << indent() << "var msg:TMessage = iprot.readMessageBegin();" << endl; 
+ 
+  // TODO(mcslee): validate message, was the seqid etc. legit? 
+  // AS- If all method is oneway: 
+  // do you have an oprot? 
+  // do you you need nullcheck? 
+  f_service_ 
+      << indent() << "var fn:Function = PROCESS_MAP[msg.name];" << endl << indent() 
+      << "if (fn == null) {" << endl << indent() << "  TProtocolUtil.skip(iprot, TType.STRUCT);" 
+      << endl << indent() << "  iprot.readMessageEnd();" << endl << indent() 
+      << "  var x:TApplicationError = new TApplicationError(TApplicationError.UNKNOWN_METHOD, " 
+         "\"Invalid method name: '\"+msg.name+\"'\");" << endl << indent() 
+      << "  oprot.writeMessageBegin(new TMessage(msg.name, TMessageType.EXCEPTION, msg.seqid));" 
+      << endl << indent() << "  x.write(oprot);" << endl << indent() << "  oprot.writeMessageEnd();" 
+      << endl << indent() << "  oprot.getTransport().flush();" << endl << indent() 
+      << "  return true;" << endl << indent() << "}" << endl << indent() 
+      << "fn.call(this,msg.seqid, iprot, oprot);" << endl; 
+ 
+  f_service_ << indent() << "return true;" << endl; 
+ 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate the process subfunctions 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_process_function(tservice, *f_iter); 
+  } 
+ 
+  indent_down(); 
+  indent(f_service_) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a struct and helpers for a function. 
+ * 
+ * @param tfunction The function 
+ */ 
+void t_as3_generator::generate_function_helpers(t_function* tfunction) { 
+  if (tfunction->is_oneway()) { 
+    return; 
+  } 
+ 
+  t_struct result(program_, tfunction->get_name() + "_result"); 
+  t_field success(tfunction->get_returntype(), "success", 0); 
+  if (!tfunction->get_returntype()->is_void()) { 
+    result.append(&success); 
+  } 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const vector<t_field*>& fields = xs->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    result.append(*f_iter); 
+  } 
+ 
+  generate_as3_struct_definition(f_service_, &result, false, true, true); 
+} 
+ 
+/** 
+ * Generates a process function definition. 
+ * 
+ * @param tfunction The function to write a dispatcher for 
+ */ 
+void t_as3_generator::generate_process_function(t_service* tservice, t_function* tfunction) { 
+  (void)tservice; 
+  // Open class 
+  indent(f_service_) << "private function " << tfunction->get_name() << "():Function {" << endl; 
+  indent_up(); 
+ 
+  // Open function 
+  indent(f_service_) << "return function(seqid:int, iprot:TProtocol, oprot:TProtocol):void" << endl; 
+  scope_up(f_service_); 
+ 
+  string argsname = tfunction->get_name() + "_args"; 
+  string resultname = tfunction->get_name() + "_result"; 
+ 
+  f_service_ << indent() << "var args:" << argsname << " = new " << argsname << "();" << endl 
+             << indent() << "args.read(iprot);" << endl << indent() << "iprot.readMessageEnd();" 
+             << endl; 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const std::vector<t_field*>& xceptions = xs->get_members(); 
+  vector<t_field*>::const_iterator x_iter; 
+ 
+  // Declare result for non oneway function 
+  if (!tfunction->is_oneway()) { 
+    f_service_ << indent() << "var result:" << resultname << " = new " << resultname << "();" 
+               << endl; 
+  } 
+ 
+  // Try block for a function with exceptions 
+  if (xceptions.size() > 0) { 
+    f_service_ << indent() << "try {" << endl; 
+    indent_up(); 
+  } 
+ 
+  // Generate the function call 
+  t_struct* arg_struct = tfunction->get_arglist(); 
+  const std::vector<t_field*>& fields = arg_struct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  f_service_ << indent(); 
+  if (tfunction->is_oneway()) { 
+    f_service_ << "iface_." << tfunction->get_name() << "("; 
+    bool first = true; 
+    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+      if (first) { 
+        first = false; 
+      } else { 
+        f_service_ << ", "; 
+      } 
+      f_service_ << "args." << (*f_iter)->get_name(); 
+    } 
+    f_service_ << ");" << endl; 
+  } else { 
+    f_service_ << "// sorry this operation is not supported yet" << endl; 
+    f_service_ << indent() << "throw new Error(\"This is not yet supported\");" << endl; 
+  } 
+ 
+  // Set isset on success field 
+  if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void() 
+      && !type_can_be_null(tfunction->get_returntype())) { 
+    f_service_ << indent() << "result.set" << get_cap_name("success") << get_cap_name("isSet") 
+               << "(true);" << endl; 
+  } 
+ 
+  if (!tfunction->is_oneway() && xceptions.size() > 0) { 
+    indent_down(); 
+    f_service_ << indent() << "}"; 
+    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+      f_service_ << " catch (" << (*x_iter)->get_name() << ":" 
+                 << type_name((*x_iter)->get_type(), false, false) << ") {" << endl; 
+      if (!tfunction->is_oneway()) { 
+        indent_up(); 
+        f_service_ << indent() << "result." << (*x_iter)->get_name() << " = " 
+                   << (*x_iter)->get_name() << ";" << endl; 
+        indent_down(); 
+        f_service_ << indent() << "}"; 
+      } else { 
+        f_service_ << "}"; 
+      } 
+    } 
+    f_service_ << " catch (th:Error) {" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "trace(\"Internal error processing " << tfunction->get_name() 
+               << "\", th);" << endl << indent() 
+               << "var x:TApplicationError = new " 
+                  "TApplicationError(TApplicationError.INTERNAL_ERROR, \"Internal error processing " 
+               << tfunction->get_name() << "\");" << endl << indent() 
+               << "oprot.writeMessageBegin(new TMessage(\"" << tfunction->get_name() 
+               << "\", TMessageType.EXCEPTION, seqid));" << endl << indent() << "x.write(oprot);" 
+               << endl << indent() << "oprot.writeMessageEnd();" << endl << indent() 
+               << "oprot.getTransport().flush();" << endl << indent() << "return;" << endl; 
+    indent_down(); 
+    f_service_ << indent() << "}" << endl; 
+  } 
+ 
+  // Shortcut out here for oneway functions 
+  if (tfunction->is_oneway()) { 
+    f_service_ << indent() << "return;" << endl; 
+    scope_down(f_service_); 
+ 
+    // Close class 
+    indent_down(); 
+    f_service_ << indent() << "}" << endl << endl; 
+    return; 
+  } 
+ 
+  f_service_ << indent() << "oprot.writeMessageBegin(new TMessage(\"" << tfunction->get_name() 
+             << "\", TMessageType.REPLY, seqid));" << endl << indent() << "result.write(oprot);" 
+             << endl << indent() << "oprot.writeMessageEnd();" << endl << indent() 
+             << "oprot.getTransport().flush();" << endl; 
+ 
+  // Close function 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Close class 
+  indent_down(); 
+  f_service_ << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Deserializes a field of any type. 
+ * 
+ * @param tfield The field 
+ * @param prefix The variable name or container for this field 
+ */ 
+void t_as3_generator::generate_deserialize_field(ostream& out, t_field* tfield, string prefix) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+ 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name(); 
+  } 
+ 
+  string name = prefix + tfield->get_name(); 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_deserialize_struct(out, (t_struct*)type, name); 
+  } else if (type->is_container()) { 
+    generate_deserialize_container(out, type, name); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+ 
+    indent(out) << name << " = iprot."; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + name; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "readBinary();"; 
+        } else { 
+          out << "readString();"; 
+        } 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "readBool();"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "readByte();"; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "readI16();"; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "readI32();"; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "readI64();"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "readDouble();"; 
+        break; 
+      default: 
+        throw "compiler error: no As3 name for base type " + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      out << "readI32();"; 
+    } 
+    out << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n", 
+           tfield->get_name().c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+/** 
+ * Generates an unserializer for a struct, invokes read() 
+ */ 
+void t_as3_generator::generate_deserialize_struct(ostream& out, t_struct* tstruct, string prefix) { 
+  out << indent() << prefix << " = new " << type_name(tstruct) << "();" << endl << indent() 
+      << prefix << ".read(iprot);" << endl; 
+} 
+ 
+/** 
+ * Deserializes a container by reading its size and then iterating 
+ */ 
+void t_as3_generator::generate_deserialize_container(ostream& out, t_type* ttype, string prefix) { 
+  scope_up(out); 
+ 
+  string obj; 
+ 
+  if (ttype->is_map()) { 
+    obj = tmp("_map"); 
+  } else if (ttype->is_set()) { 
+    obj = tmp("_set"); 
+  } else if (ttype->is_list()) { 
+    obj = tmp("_list"); 
+  } 
+ 
+  // Declare variables, read header 
+  if (ttype->is_map()) { 
+    indent(out) << "var " << obj << ":TMap = iprot.readMapBegin();" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "var " << obj << ":TSet = iprot.readSetBegin();" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "var " << obj << ":TList = iprot.readListBegin();" << endl; 
+  } 
+ 
+  indent(out) << prefix << " = new " << type_name(ttype, false, true) 
+              // size the collection correctly 
+              << "(" 
+              << ");" << endl; 
+ 
+  // For loop iterates over elements 
+  string i = tmp("_i"); 
+  indent(out) << "for (var " << i << ":int = 0; " << i << " < " << obj << ".size" 
+              << "; " 
+              << "++" << i << ")" << endl; 
+ 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    generate_deserialize_map_element(out, (t_map*)ttype, prefix); 
+  } else if (ttype->is_set()) { 
+    generate_deserialize_set_element(out, (t_set*)ttype, prefix); 
+  } else if (ttype->is_list()) { 
+    generate_deserialize_list_element(out, (t_list*)ttype, prefix); 
+  } 
+ 
+  scope_down(out); 
+ 
+  // Read container end 
+  if (ttype->is_map()) { 
+    indent(out) << "iprot.readMapEnd();" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "iprot.readSetEnd();" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "iprot.readListEnd();" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+/** 
+ * Generates code to deserialize a map 
+ */ 
+void t_as3_generator::generate_deserialize_map_element(ostream& out, t_map* tmap, string prefix) { 
+  string key = tmp("_key"); 
+  string val = tmp("_val"); 
+  t_field fkey(tmap->get_key_type(), key); 
+  t_field fval(tmap->get_val_type(), val); 
+ 
+  indent(out) << declare_field(&fkey) << endl; 
+  indent(out) << declare_field(&fval) << endl; 
+ 
+  generate_deserialize_field(out, &fkey); 
+  generate_deserialize_field(out, &fval); 
+ 
+  indent(out) << prefix << "[" << key << "] = " << val << ";" << endl; 
+} 
+ 
+/** 
+ * Deserializes a set element 
+ */ 
+void t_as3_generator::generate_deserialize_set_element(ostream& out, t_set* tset, string prefix) { 
+  string elem = tmp("_elem"); 
+  t_field felem(tset->get_elem_type(), elem); 
+ 
+  indent(out) << declare_field(&felem) << endl; 
+ 
+  generate_deserialize_field(out, &felem); 
+ 
+  indent(out) << prefix << ".add(" << elem << ");" << endl; 
+} 
+ 
+/** 
+ * Deserializes a list element 
+ */ 
+void t_as3_generator::generate_deserialize_list_element(ostream& out, 
+                                                        t_list* tlist, 
+                                                        string prefix) { 
+  string elem = tmp("_elem"); 
+  t_field felem(tlist->get_elem_type(), elem); 
+ 
+  indent(out) << declare_field(&felem) << endl; 
+ 
+  generate_deserialize_field(out, &felem); 
+ 
+  indent(out) << prefix << ".push(" << elem << ");" << endl; 
+} 
+ 
+/** 
+ * Serializes a field of any type. 
+ * 
+ * @param tfield The field to serialize 
+ * @param prefix Name to prepend to field name 
+ */ 
+void t_as3_generator::generate_serialize_field(ostream& out, t_field* tfield, string prefix) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+ 
+  // Do nothing for void types 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name(); 
+  } 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_serialize_struct(out, (t_struct*)type, prefix + tfield->get_name()); 
+  } else if (type->is_container()) { 
+    generate_serialize_container(out, type, prefix + tfield->get_name()); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+ 
+    string name = prefix + tfield->get_name(); 
+    indent(out) << "oprot."; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + name; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "writeBinary(" << name << ");"; 
+        } else { 
+          out << "writeString(" << name << ");"; 
+        } 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "writeBool(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "writeByte(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "writeI16(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "writeI32(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "writeI64(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "writeDouble(" << name << ");"; 
+        break; 
+      default: 
+        throw "compiler error: no As3 name for base type " + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      out << "writeI32(" << name << ");"; 
+    } 
+    out << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s%s' TYPE '%s'\n", 
+           prefix.c_str(), 
+           tfield->get_name().c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+/** 
+ * Serializes all the members of a struct. 
+ * 
+ * @param tstruct The struct to serialize 
+ * @param prefix  String prefix to attach to all fields 
+ */ 
+void t_as3_generator::generate_serialize_struct(ostream& out, t_struct* tstruct, string prefix) { 
+  (void)tstruct; 
+  out << indent() << prefix << ".write(oprot);" << endl; 
+} 
+ 
+/** 
+ * Serializes a container by writing its size then the elements. 
+ * 
+ * @param ttype  The type of container 
+ * @param prefix String prefix for fields 
+ */ 
+void t_as3_generator::generate_serialize_container(ostream& out, t_type* ttype, string prefix) { 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    string iter = tmp("_key"); 
+    string counter = tmp("_sizeCounter"); 
+    indent(out) << "var " << counter << ":int = 0;" << endl; 
+    indent(out) << "for (var " << iter << ":* in " << prefix << ") {" << endl; 
+    indent(out) << "  " << counter << +"++;" << endl; 
+    indent(out) << "}" << endl; 
+ 
+    indent(out) << "oprot.writeMapBegin(new TMap(" << type_to_enum(((t_map*)ttype)->get_key_type()) 
+                << ", " << type_to_enum(((t_map*)ttype)->get_val_type()) << ", " << counter << "));" 
+                << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "oprot.writeSetBegin(new TSet(" << type_to_enum(((t_set*)ttype)->get_elem_type()) 
+                << ", " << prefix << ".size));" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "oprot.writeListBegin(new TList(" 
+                << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", " << prefix << ".length));" 
+                << endl; 
+  } 
+ 
+  string iter = tmp("elem"); 
+  if (ttype->is_map()) { 
+    indent(out) << "for (var " << iter << ":* in " << prefix << ")"; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "for each (var " << iter << ":* in " << prefix << ".toArray())"; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "for each (var " << iter << ":* in " << prefix << ")"; 
+  } 
+ 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    generate_serialize_map_element(out, (t_map*)ttype, iter, prefix); 
+  } else if (ttype->is_set()) { 
+    generate_serialize_set_element(out, (t_set*)ttype, iter); 
+  } else if (ttype->is_list()) { 
+    generate_serialize_list_element(out, (t_list*)ttype, iter); 
+  } 
+ 
+  scope_down(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "oprot.writeMapEnd();" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "oprot.writeSetEnd();" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "oprot.writeListEnd();" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+/** 
+ * Serializes the members of a map. 
+ */ 
+void t_as3_generator::generate_serialize_map_element(ostream& out, 
+                                                     t_map* tmap, 
+                                                     string iter, 
+                                                     string map) { 
+  t_field kfield(tmap->get_key_type(), iter); 
+  generate_serialize_field(out, &kfield, ""); 
+  t_field vfield(tmap->get_val_type(), map + "[" + iter + "]"); 
+  generate_serialize_field(out, &vfield, ""); 
+} 
+ 
+/** 
+ * Serializes the members of a set. 
+ */ 
+void t_as3_generator::generate_serialize_set_element(ostream& out, t_set* tset, string iter) { 
+  t_field efield(tset->get_elem_type(), iter); 
+  generate_serialize_field(out, &efield, ""); 
+} 
+ 
+/** 
+ * Serializes the members of a list. 
+ */ 
+void t_as3_generator::generate_serialize_list_element(ostream& out, t_list* tlist, string iter) { 
+  t_field efield(tlist->get_elem_type(), iter); 
+  generate_serialize_field(out, &efield, ""); 
+} 
+ 
+/** 
+ * Returns a As3 type name 
+ * 
+ * @param ttype The type 
+ * @param container Is the type going inside a container? 
+ * @return As3 type name, i.e. HashMap<Key,Value> 
+ */ 
+string t_as3_generator::type_name(t_type* ttype, bool in_container, bool in_init) { 
+  (void)in_init; 
+  // In As3 typedefs are just resolved to their real type 
+  ttype = get_true_type(ttype); 
+  string prefix; 
+ 
+  if (ttype->is_base_type()) { 
+    return base_type_name((t_base_type*)ttype, in_container); 
+  } else if (ttype->is_enum()) { 
+    return "int"; 
+  } else if (ttype->is_map()) { 
+    return "Dictionary"; 
+  } else if (ttype->is_set()) { 
+    return "Set"; 
+  } else if (ttype->is_list()) { 
+    return "Array"; 
+  } 
+ 
+  // Check for namespacing 
+  t_program* program = ttype->get_program(); 
+  if (program != NULL && program != program_) { 
+    string package = program->get_namespace("as3"); 
+    if (!package.empty()) { 
+      return package + "." + ttype->get_name(); 
+    } 
+  } 
+ 
+  return ttype->get_name(); 
+} 
+ 
+/** 
+ * Returns the AS3 type that corresponds to the thrift type. 
+ * 
+ * @param tbase The base type 
+ * @param container Is it going in a As3 container? 
+ */ 
+string t_as3_generator::base_type_name(t_base_type* type, bool in_container) { 
+  (void)in_container; 
+  t_base_type::t_base tbase = type->get_base(); 
+ 
+  switch (tbase) { 
+  case t_base_type::TYPE_VOID: 
+    return "void"; 
+  case t_base_type::TYPE_STRING: 
+    if (type->is_binary()) { 
+      return "ByteArray"; 
+    } else { 
+      return "String"; 
+    } 
+  case t_base_type::TYPE_BOOL: 
+    return "Boolean"; 
+  case t_base_type::TYPE_I8: 
+  case t_base_type::TYPE_I16: 
+  case t_base_type::TYPE_I32: 
+    return "int"; 
+  case t_base_type::TYPE_I64: 
+    throw "i64 is not yet supported in as3"; 
+  case t_base_type::TYPE_DOUBLE: 
+    return "Number"; 
+  default: 
+    throw "compiler error: no As3 name for base type " + t_base_type::t_base_name(tbase); 
+  } 
+} 
+ 
+/** 
+ * Declares a field, which may include initialization as necessary. 
+ * 
+ * @param ttype The type 
+ */ 
+string t_as3_generator::declare_field(t_field* tfield, bool init) { 
+  // TODO(mcslee): do we ever need to initialize the field? 
+  string result = "var " + tfield->get_name() + ":" + type_name(tfield->get_type()); 
+  if (init) { 
+    t_type* ttype = get_true_type(tfield->get_type()); 
+    if (ttype->is_base_type() && tfield->get_value() != NULL) { 
+      std::ofstream dummy; 
+      result += " = " + render_const_value(dummy, tfield->get_name(), ttype, tfield->get_value()); 
+    } else if (ttype->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "NO T_VOID CONSTRUCT"; 
+      case t_base_type::TYPE_STRING: 
+        result += " = null"; 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        result += " = false"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+      case t_base_type::TYPE_I16: 
+      case t_base_type::TYPE_I32: 
+      case t_base_type::TYPE_I64: 
+        result += " = 0"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        result += " = (double)0"; 
+        break; 
+      } 
+ 
+    } else if (ttype->is_enum()) { 
+      result += " = 0"; 
+    } else if (ttype->is_container()) { 
+      result += " = new " + type_name(ttype, false, true) + "()"; 
+    } else { 
+      result += " = new " + type_name(ttype, false, true) + "()"; 
+      ; 
+    } 
+  } 
+  return result + ";"; 
+} 
+ 
+/** 
+ * Renders a function signature of the form 'type name(args)' 
+ * 
+ * @param tfunction Function definition 
+ * @return String of rendered function definition 
+ */ 
+string t_as3_generator::function_signature(t_function* tfunction, string prefix) { 
+  std::string arguments = argument_list(tfunction->get_arglist()); 
+  if (!tfunction->is_oneway()) { 
+    if (arguments != "") { 
+      arguments += ", "; 
+    } 
+    arguments += "onError:Function, onSuccess:Function"; 
+  } 
+ 
+  std::string result = "function " + prefix + tfunction->get_name() + "(" + arguments + "):void"; 
+  return result; 
+} 
+ 
+/** 
+ * Renders a comma separated field list, with type names 
+ */ 
+string t_as3_generator::argument_list(t_struct* tstruct) { 
+  string result = ""; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      result += ", "; 
+    } 
+    result += (*f_iter)->get_name() + ":" + type_name((*f_iter)->get_type()); 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Converts the parse type to a C++ enum string for the given type. 
+ */ 
+string t_as3_generator::type_to_enum(t_type* type) { 
+  type = get_true_type(type); 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "NO T_VOID CONSTRUCT"; 
+    case t_base_type::TYPE_STRING: 
+      return "TType.STRING"; 
+    case t_base_type::TYPE_BOOL: 
+      return "TType.BOOL"; 
+    case t_base_type::TYPE_I8: 
+      return "TType.BYTE"; 
+    case t_base_type::TYPE_I16: 
+      return "TType.I16"; 
+    case t_base_type::TYPE_I32: 
+      return "TType.I32"; 
+    case t_base_type::TYPE_I64: 
+      return "TType.I64"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "TType.DOUBLE"; 
+    } 
+  } else if (type->is_enum()) { 
+    return "TType.I32"; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    return "TType.STRUCT"; 
+  } else if (type->is_map()) { 
+    return "TType.MAP"; 
+  } else if (type->is_set()) { 
+    return "TType.SET"; 
+  } else if (type->is_list()) { 
+    return "TType.LIST"; 
+  } 
+ 
+  throw "INVALID TYPE IN type_to_enum: " + type->get_name(); 
+} 
+ 
+/** 
+ * Applies the correct style to a string based on the value of nocamel_style_ 
+ */ 
+std::string t_as3_generator::get_cap_name(std::string name) { 
+  name[0] = toupper(name[0]); 
+  return name; 
+} 
+ 
+string t_as3_generator::constant_name(string name) { 
+  string constant_name; 
+ 
+  bool is_first = true; 
+  bool was_previous_char_upper = false; 
+  for (string::iterator iter = name.begin(); iter != name.end(); ++iter) { 
+    string::value_type character = (*iter); 
+ 
+    bool is_upper = isupper(character); 
+ 
+    if (is_upper && !is_first && !was_previous_char_upper) { 
+      constant_name += '_'; 
+    } 
+    constant_name += toupper(character); 
+ 
+    is_first = false; 
+    was_previous_char_upper = is_upper; 
+  } 
+ 
+  return constant_name; 
+} 
+ 
+/** 
+ * Emits a As3Doc comment if the provided object has a doc in Thrift 
+ */ 
+void t_as3_generator::generate_as3_doc(ostream& out, t_doc* tdoc) { 
+  if (tdoc->has_doc()) { 
+    generate_docstring_comment(out, "/**\n", " * ", tdoc->get_doc(), " */\n"); 
+  } 
+} 
+ 
+/** 
+ * Emits a As3Doc comment if the provided function object has a doc in Thrift 
+ */ 
+void t_as3_generator::generate_as3_doc(ostream& out, t_function* tfunction) { 
+  if (tfunction->has_doc()) { 
+    stringstream ss; 
+    ss << tfunction->get_doc(); 
+    const vector<t_field*>& fields = tfunction->get_arglist()->get_members(); 
+    vector<t_field*>::const_iterator p_iter; 
+    for (p_iter = fields.begin(); p_iter != fields.end(); ++p_iter) { 
+      t_field* p = *p_iter; 
+      ss << "\n@param " << p->get_name(); 
+      if (p->has_doc()) { 
+        ss << " " << p->get_doc(); 
+      } 
+    } 
+    generate_docstring_comment(out, "/**\n", " * ", ss.str(), " */\n"); 
+  } 
+} 
+ 
+std::string t_as3_generator::generate_isset_check(t_field* field) { 
+  return generate_isset_check(field->get_name()); 
+} 
+ 
+std::string t_as3_generator::generate_isset_check(std::string field_name) { 
+  return "is" + get_cap_name("set") + get_cap_name(field_name) + "()"; 
+} 
+ 
+void t_as3_generator::generate_isset_set(ostream& out, t_field* field) { 
+  if (!type_can_be_null(field->get_type())) { 
+    indent(out) << "this.__isset_" << field->get_name() << " = true;" << endl; 
+  } 
+} 
+ 
+std::string t_as3_generator::get_enum_class_name(t_type* type) { 
+  string package = ""; 
+  t_program* program = type->get_program(); 
+  if (program != NULL && program != program_) { 
+    package = program->get_namespace("as3") + "."; 
+  } 
+  return package + type->get_name(); 
+} 
+ 
+THRIFT_REGISTER_GENERATOR( 
+    as3, 
+    "AS3", 
+    "    bindable:        Add [bindable] metadata to all the struct classes.\n") 

contrib/restricted/thrift/compiler/thrift/generate/t_c_glib_generator.cc

@@ -1,4562 +1,4562 @@
-/*
- * 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.
- *
- * Contains some contributions under the Thrift Software License.
- * Please see doc/old-thrift-license.txt in the Thrift distribution for
- * details.
- */
-
-#include <fstream>
-#include <iostream>
-#include <stdexcept>
-#include <string>
-#include <vector>
-
-#include <ctype.h>
-
-#include "thrift/platform.h"
-#include "thrift/generate/t_oop_generator.h"
-
-using std::map;
-using std::ostream;
-using std::ostringstream;
-using std::string;
-using std::stringstream;
-using std::vector;
-
-static const string endl = "\n"; // avoid ostream << std::endl flushes
-
-/* forward declarations */
-string initial_caps_to_underscores(string name);
-string underscores_to_initial_caps(string name);
-string to_upper_case(string name);
-string to_lower_case(string name);
-
-/**
- * C code generator, using glib for C typing.
- */
-class t_c_glib_generator : public t_oop_generator {
-public:
-  /* constructor */
-  t_c_glib_generator(t_program* program,
-                     const map<string, string>& parsed_options,
-                     const string& option_string)
-    : t_oop_generator(program) {
-    (void)option_string;
-    std::map<std::string, std::string>::const_iterator iter;
-
-    /* set the output directory */
-    this->out_dir_base_ = "gen-c_glib";
-
-    /* no options yet */
-    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
-      throw "unknown option c_glib:" + iter->first;
-    }
-
-    /* set the namespace */
-    this->nspace = program_->get_namespace("c_glib");
-
-    if (this->nspace.empty()) {
-      this->nspace = "";
-      this->nspace_u = "";
-      this->nspace_uc = "";
-      this->nspace_lc = "";
-    } else {
-      /* replace dots with underscores */
-      char* tmp = strdup(this->nspace.c_str());
-      for (unsigned int i = 0; i < strlen(tmp); i++) {
-        if (tmp[i] == '.') {
-          tmp[i] = '_';
-        }
-      }
-      this->nspace = string(tmp, strlen(tmp));
-      free(tmp);
-
-      /* clean up the namespace for C.
-       * An input of 'namespace foo' should result in:
-       *  - nspace = foo       - for thrift objects and typedefs
-       *  - nspace_u = Foo     - for internal GObject prefixes
-       *  - nspace_uc = FOO_   - for macro prefixes
-       *  - nspace_lc = foo_   - for filename and method prefixes
-       * The underscores are there since uc and lc strings are used as file and
-       * variable prefixes.
-       */
-      this->nspace_u = initial_caps_to_underscores(this->nspace);
-      this->nspace_uc = to_upper_case(this->nspace_u) + "_";
-      this->nspace_lc = to_lower_case(this->nspace_u) + "_";
-    }
-  }
-
-  /* initialization and destruction */
-  void init_generator();
-  void close_generator();
-
-  /* generation functions */
-  void generate_typedef(t_typedef* ttypedef);
-  void generate_enum(t_enum* tenum);
-  void generate_consts(vector<t_const*> consts);
-  void generate_struct(t_struct* tstruct);
-  void generate_service(t_service* tservice);
-  void generate_xception(t_struct* tstruct);
-
-private:
-  /* file streams */
-  ofstream_with_content_based_conditional_update f_types_;
-  ofstream_with_content_based_conditional_update f_types_impl_;
-  ofstream_with_content_based_conditional_update f_header_;
-  ofstream_with_content_based_conditional_update f_service_;
-
-  /* namespace variables */
-  string nspace;
-  string nspace_u;
-  string nspace_uc;
-  string nspace_lc;
-
-  /* helper functions */
-  bool is_complex_type(t_type* ttype);
-  bool is_numeric(t_type* ttype);
-  string type_name(t_type* ttype, bool in_typedef = false, bool is_const = false);
-  string property_type_name(t_type* ttype, bool in_typedef = false, bool is_const = false);
-  string base_type_name(t_type* type);
-  string type_to_enum(t_type* type);
-  string constant_literal(t_type* type, t_const_value* value);
-  string constant_value(string name, t_type* type, t_const_value* value);
-  string constant_value_with_storage(string name, t_type* type, t_const_value* value);
-  string function_signature(t_function* tfunction);
-  string argument_list(t_struct* tstruct);
-  string xception_list(t_struct* tstruct);
-  string declare_field(t_field* tfield,
-                       bool init = false,
-                       bool pointer = false,
-                       bool constant = false,
-                       bool reference = false);
-  void declare_local_variable(ostream& out, t_type* ttype, string& base_name, bool for_hash_table);
-  void declore_local_variable_for_write(ostream& out, t_type* ttype, string& base_name);
-
-  /* generation functions */
-  void generate_const_initializer(string name,
-                                  t_type* type,
-                                  t_const_value* value,
-                                  bool top_level = false);
-  void generate_service_helpers(t_service* tservice);
-  void generate_service_client(t_service* tservice);
-  void generate_service_handler(t_service* tservice);
-  void generate_service_processor(t_service* tservice);
-  void generate_service_server(t_service* tservice);
-  void generate_object(t_struct* tstruct);
-  void generate_struct_writer(ostream& out,
-                              t_struct* tstruct,
-                              string this_name,
-                              string this_get = "",
-                              bool is_function = true);
-  void generate_struct_reader(ostream& out,
-                              t_struct* tstruct,
-                              string this_name,
-                              string this_get = "",
-                              bool is_function = true);
-
-  void generate_serialize_field(ostream& out,
-                                t_field* tfield,
-                                string prefix,
-                                string suffix,
-                                int error_ret);
-  void generate_serialize_struct(ostream& out, t_struct* tstruct, string prefix, int error_ret);
-  void generate_serialize_container(ostream& out, t_type* ttype, string prefix, int error_ret);
-  void generate_serialize_map_element(ostream& out,
-                                      t_map* tmap,
-                                      string key,
-                                      string value,
-                                      int error_ret);
-  void generate_serialize_set_element(ostream& out, t_set* tset, string element, int error_ret);
-  void generate_serialize_list_element(ostream& out,
-                                       t_list* tlist,
-                                       string list,
-                                       string index,
-                                       int error_ret);
-
-  void generate_deserialize_field(ostream& out,
-                                  t_field* tfield,
-                                  string prefix,
-                                  string suffix,
-                                  int error_ret,
-                                  bool allocate = true);
-  void generate_deserialize_struct(ostream& out,
-                                   t_struct* tstruct,
-                                   string prefix,
-                                   int error_ret,
-                                   bool allocate = true);
-  void generate_deserialize_container(ostream& out, t_type* ttype, string prefix, int error_ret);
-  void generate_deserialize_map_element(ostream& out, t_map* tmap, string prefix, int error_ret);
-  void generate_deserialize_set_element(ostream& out, t_set* tset, string prefix, int error_ret);
-  void generate_deserialize_list_element(ostream& out,
-                                         t_list* tlist,
-                                         string prefix,
-                                         string index,
-                                         int error_ret);
-
-  string generate_new_hash_from_type(t_type* key, t_type* value);
-  string generate_new_array_from_type(t_type* ttype);
-
-  string generate_free_func_from_type(t_type* ttype);
-  string generate_hash_func_from_type(t_type* ttype);
-  string generate_cmp_func_from_type(t_type* ttype);
-};
-
-/**
- * Prepare for file generation by opening up the necessary file
- * output streams.
- */
-void t_c_glib_generator::init_generator() {
-  /* create output directory */
-  MKDIR(get_out_dir().c_str());
-
-  string program_name_u = initial_caps_to_underscores(program_name_);
-  string program_name_uc = to_upper_case(program_name_u);
-  string program_name_lc = to_lower_case(program_name_u);
-
-  /* create output files */
-  string f_types_name = get_out_dir() + this->nspace_lc + program_name_lc + "_types.h";
-  f_types_.open(f_types_name.c_str());
-  string f_types_impl_name = get_out_dir() + this->nspace_lc + program_name_lc + "_types.c";
-  f_types_impl_.open(f_types_impl_name.c_str());
-
-  /* add thrift boilerplate headers */
-  f_types_ << autogen_comment();
-  f_types_impl_ << autogen_comment();
-
-  /* include inclusion guard */
-  f_types_ << "#ifndef " << this->nspace_uc << program_name_uc << "_TYPES_H" << endl << "#define "
-           << this->nspace_uc << program_name_uc << "_TYPES_H" << endl << endl;
-
-  /* include base types */
-  f_types_ << "/* base includes */" << endl << "#include <glib-object.h>" << endl
-           << "#include <thrift/c_glib/thrift_struct.h>" << endl
-           << "#include <thrift/c_glib/protocol/thrift_protocol.h>" << endl;
-
-  /* include other thrift includes */
-  const vector<t_program*>& includes = program_->get_includes();
-  for (size_t i = 0; i < includes.size(); ++i) {
-    f_types_ << "/* other thrift includes */" << endl << "#include \"" << this->nspace_lc
-             << initial_caps_to_underscores(includes[i]->get_name()) << "_types.h\"" << endl;
-  }
-  f_types_ << endl;
-
-  /* include custom headers */
-  const vector<string>& c_includes = program_->get_c_includes();
-  f_types_ << "/* custom thrift includes */" << endl;
-  for (size_t i = 0; i < c_includes.size(); ++i) {
-    if (c_includes[i][0] == '<') {
-      f_types_ << "#include " << c_includes[i] << endl;
-    } else {
-      f_types_ << "#include \"" << c_includes[i] << "\"" << endl;
-    }
-  }
-  f_types_ << endl;
-
-  /* include math.h (for "INFINITY") in the implementation file, in case we
-     encounter a struct with a member of type double */
-  f_types_impl_ << endl << "#include <math.h>" << endl;
-
-  // include the types file
-  f_types_impl_ << endl << "#include \"" << this->nspace_lc << program_name_u << "_types.h\""
-                << endl << "#include <thrift/c_glib/thrift.h>" << endl << endl;
-
-  f_types_ << "/* begin types */" << endl << endl;
-}
-
-/**
- *  Finish up generation and close all file streams.
- */
-void t_c_glib_generator::close_generator() {
-  string program_name_uc = to_upper_case(initial_caps_to_underscores(program_name_));
-
-  /* end the header inclusion guard */
-  f_types_ << "#endif /* " << this->nspace_uc << program_name_uc << "_TYPES_H */" << endl;
-
-  /* close output file */
-  f_types_.close();
-  f_types_impl_.close();
-}
-
-/**
- * Generates a Thrift typedef in C code.  For example:
- *
- * Thrift:
- * typedef map<i32,i32> SomeMap
- *
- * C:
- * typedef GHashTable * ThriftSomeMap;
- */
-void t_c_glib_generator::generate_typedef(t_typedef* ttypedef) {
-  f_types_ << indent() << "typedef " << type_name(ttypedef->get_type(), true) << " " << this->nspace
-           << ttypedef->get_symbolic() << ";" << endl << endl;
-}
-
-/**
- * Generates a C enumeration.  For example:
- *
- * Thrift:
- * enum MyEnum {
- *   ONE = 1,
- *   TWO
- * }
- *
- * C:
- * enum _ThriftMyEnum {
- *   THRIFT_MY_ENUM_ONE = 1,
- *   THRIFT_MY_ENUM_TWO
- * };
- * typedef enum _ThriftMyEnum ThriftMyEnum;
- */
-void t_c_glib_generator::generate_enum(t_enum* tenum) {
-  string name = tenum->get_name();
-  string name_uc = to_upper_case(initial_caps_to_underscores(name));
-
-  f_types_ << indent() << "enum _" << this->nspace << name << " {" << endl;
-
-  indent_up();
-
-  vector<t_enum_value*> constants = tenum->get_constants();
-  vector<t_enum_value*>::iterator c_iter;
-  bool first = true;
-
-  /* output each of the enumeration elements */
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    if (first) {
-      first = false;
-    } else {
-      f_types_ << "," << endl;
-    }
-
-    f_types_ << indent() << this->nspace_uc << name_uc << "_" << (*c_iter)->get_name();
-    f_types_ << " = " << (*c_iter)->get_value();
-  }
-
-  indent_down();
-  f_types_ << endl << "};" << endl << "typedef enum _" << this->nspace << name << " "
-           << this->nspace << name << ";" << endl << endl;
-
-  f_types_ << "/* return the name of the constant */" << endl;
-  f_types_ << "const char *" << endl;
-  f_types_ << "toString_" << name << "(int value); " << endl << endl;
-  ;
-  f_types_impl_ << "/* return the name of the constant */" << endl;
-  f_types_impl_ << "const char *" << endl;
-  f_types_impl_ << "toString_" << name << "(int value) " << endl;
-  f_types_impl_ << "{" << endl;
-  f_types_impl_ << "  static __thread char buf[16] = {0};" << endl;
-  f_types_impl_ << "  switch(value) {" << endl;
-  std::set<int> done;
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    int value = (*c_iter)->get_value();
-    // Skipping duplicate value
-    if (done.find(value) == done.end()) {
-      done.insert(value);
-      f_types_impl_ << "  case " << this->nspace_uc << name_uc << "_" << (*c_iter)->get_name()
-                    << ":"
-                    << "return \"" << this->nspace_uc << name_uc << "_" << (*c_iter)->get_name()
-                    << "\";" << endl;
-    }
-  }
-  f_types_impl_ << "  default: g_snprintf(buf, 16, \"%d\", value); return buf;" << endl;
-  f_types_impl_ << "  }" << endl;
-  f_types_impl_ << "}" << endl << endl;
-}
-
-/**
- * Generates Thrift constants in C code.
- */
-void t_c_glib_generator::generate_consts(vector<t_const*> consts) {
-  f_types_ << "/* constants */" << endl;
-  f_types_impl_ << "/* constants */" << endl;
-
-  vector<t_const*>::iterator c_iter;
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    string name = (*c_iter)->get_name();
-    string name_uc = to_upper_case(name);
-    string name_lc = to_lower_case(name);
-    t_type* type = (*c_iter)->get_type();
-    t_const_value* value = (*c_iter)->get_value();
-
-    if (is_complex_type(type)) {
-      f_types_ << type_name(type) << indent() << this->nspace_lc << name_lc
-               << "_constant();" << endl;
-    }
-
-    f_types_ << indent() << "#define " << this->nspace_uc << name_uc << " "
-             << constant_value(name_lc, type, value) << endl;
-
-    generate_const_initializer(name_lc, type, value, true);
-  }
-
-  f_types_ << endl;
-  f_types_impl_ << endl;
-}
-
-/**
- * Generate Thrift structs in C code, as GObjects.  Example:
- *
- * Thrift:
- * struct Bonk
- * {
- *   1: string message,
- *   2: i32 type
- * }
- *
- * C GObject instance header:
- * struct _ThriftBonk
- * {
- *   GObject parent;
- *
- *   gchar * message;
- *   gint32 type;
- * };
- * typedef struct _ThriftBonk ThriftBonk
- * // ... additional GObject boilerplate ...
- */
-void t_c_glib_generator::generate_struct(t_struct* tstruct) {
-  f_types_ << "/* struct " << tstruct->get_name() << " */" << endl;
-  generate_object(tstruct);
-}
-
-/**
- * Generate C code to represent Thrift services.  Creates a new GObject
- * which can be used to access the service.
- */
-void t_c_glib_generator::generate_service(t_service* tservice) {
-  string svcname_u = initial_caps_to_underscores(tservice->get_name());
-  string svcname_uc = this->nspace_uc + to_upper_case(svcname_u);
-  string filename = this->nspace_lc + to_lower_case(svcname_u);
-
-  // make output files
-  string f_header_name = get_out_dir() + filename + ".h";
-  f_header_.open(f_header_name.c_str());
-
-  string program_name_u = initial_caps_to_underscores(program_name_);
-  string program_name_lc = to_lower_case(program_name_u);
-
-  // add header file boilerplate
-  f_header_ << autogen_comment();
-
-  // add an inclusion guard
-  f_header_ << "#ifndef " << svcname_uc << "_H" << endl << "#define " << svcname_uc << "_H" << endl
-            << endl;
-
-  // add standard includes
-  f_header_ << "#include <thrift/c_glib/processor/thrift_dispatch_processor.h>" << endl << endl;
-  f_header_ << "#include \"" << this->nspace_lc << program_name_lc << "_types.h\"" << endl;
-
-  // if we are inheriting from another service, include its header
-  t_service* extends_service = tservice->get_extends();
-  if (extends_service != NULL) {
-    f_header_ << "#include \"" << this->nspace_lc
-              << to_lower_case(initial_caps_to_underscores(extends_service->get_name())) << ".h\""
-              << endl;
-  }
-  f_header_ << endl;
-
-  // create the service implementation
-  string f_service_name = get_out_dir() + filename + ".c";
-  f_service_.open(f_service_name.c_str());
-
-  // add the boilerplace header
-  f_service_ << autogen_comment();
-
-  // include the headers
-  f_service_ << "#include <string.h>" << endl << "#include <thrift/c_glib/thrift.h>" << endl
-             << "#include <thrift/c_glib/thrift_application_exception.h>" << endl << "#include \""
-             << filename << ".h\"" << endl << endl;
-
-  // generate the service-helper classes
-  generate_service_helpers(tservice);
-
-  // generate the client objects
-  generate_service_client(tservice);
-
-  // generate the server objects
-  generate_service_server(tservice);
-
-  // end the header inclusion guard
-  f_header_ << "#endif /* " << svcname_uc << "_H */" << endl;
-
-  // close the files
-  f_service_.close();
-  f_header_.close();
-}
-
-/**
- *
- */
-void t_c_glib_generator::generate_xception(t_struct* tstruct) {
-  string name = tstruct->get_name();
-  string name_u = initial_caps_to_underscores(name);
-  string name_lc = to_lower_case(name_u);
-  string name_uc = to_upper_case(name_u);
-
-  generate_object(tstruct);
-
-  f_types_ << "/* exception */" << endl
-           << "typedef enum" << endl
-           << "{" << endl;
-  indent_up();
-  f_types_ << indent() << this->nspace_uc << name_uc << "_ERROR_CODE" << endl;
-  indent_down();
-  f_types_ << "} " << this->nspace << name << "Error;" << endl
-           << endl
-           << "GQuark " << this->nspace_lc << name_lc
-           << "_error_quark (void);" << endl
-           << "#define " << this->nspace_uc << name_uc << "_ERROR ("
-           << this->nspace_lc << name_lc << "_error_quark())" << endl
-           << endl
-           << endl;
-
-  f_types_impl_ << "/* define the GError domain for exceptions */" << endl << "#define "
-                << this->nspace_uc << name_uc << "_ERROR_DOMAIN \"" << this->nspace_lc << name_lc
-                << "_error_quark\"" << endl << "GQuark" << endl << this->nspace_lc << name_lc
-                << "_error_quark (void)" << endl << "{" << endl
-                << "  return g_quark_from_static_string (" << this->nspace_uc << name_uc
-                << "_ERROR_DOMAIN);" << endl << "}" << endl << endl;
-}
-
-/********************
- * HELPER FUNCTIONS *
- ********************/
-
-/**
- * Returns true if ttype is not a primitive.
- */
-bool t_c_glib_generator::is_complex_type(t_type* ttype) {
-  ttype = get_true_type(ttype);
-
-  return ttype->is_container() || ttype->is_struct() || ttype->is_xception();
-}
-
-bool t_c_glib_generator::is_numeric(t_type* ttype) {
-  return ttype->is_enum() || (ttype->is_base_type() && !ttype->is_string());
-}
-
-/**
- * Maps a Thrift t_type to a C type.
- */
-string t_c_glib_generator::type_name(t_type* ttype, bool in_typedef, bool is_const) {
-  if (ttype->is_base_type()) {
-    string bname = base_type_name(ttype);
-
-    if (is_const) {
-      return "const " + bname;
-    } else {
-      return bname;
-    }
-  }
-
-  if (ttype->is_container()) {
-    string cname;
-
-    t_container* tcontainer = (t_container*)ttype;
-    if (tcontainer->has_cpp_name()) {
-      cname = tcontainer->get_cpp_name();
-    } else if (ttype->is_map()) {
-      cname = "GHashTable";
-    } else if (ttype->is_set()) {
-      // since a set requires unique elements, use a GHashTable, and
-      // populate the keys and values with the same data, using keys for
-      // the actual writes and reads.
-      // TODO: discuss whether or not to implement TSet, THashSet or GHashSet
-      cname = "GHashTable";
-    } else if (ttype->is_list()) {
-      t_type* etype = ((t_list*)ttype)->get_elem_type();
-      if (etype->is_void()) {
-        throw std::runtime_error("compiler error: list element type cannot be void");
-      }
-      // TODO: investigate other implementations besides GPtrArray
-      cname = is_numeric(etype) ? "GArray" : "GPtrArray";
-    }
-
-    /* Omit the dereference operator if we are aliasing this type within a
-       typedef, to allow the type to be used more naturally in client code;
-       otherwise, include it */
-    if (!in_typedef) {
-      cname += " *";
-    }
-
-    if (is_const) {
-      return "const " + cname;
-    } else {
-      return cname;
-    }
-  }
-
-  // check for a namespace
-  string pname = this->nspace + ttype->get_name();
-
-  if (is_complex_type(ttype)) {
-    pname += " *";
-  }
-
-  if (is_const) {
-    return "const " + pname;
-  } else {
-    return pname;
-  }
-}
-
-/**
- * Maps a Thrift primitive to the type needed to hold its value when used as an
- * object property.
- *
- * This method is needed because all integer properties of width less than 64
- * bits map to the same type, gint, as opposed to their width-specific type
- * (gint8, gint16 or gint32).
- */
-string t_c_glib_generator::property_type_name(t_type* ttype, bool in_typedef, bool is_const) {
-  string result;
-
-  if (ttype->is_base_type()) {
-    switch (((t_base_type*)ttype)->get_base()) {
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-      if (is_const) {
-        result = "const gint";
-      } else {
-        result = "gint";
-      }
-      break;
-
-    default:
-      result = type_name(ttype, in_typedef, is_const);
-    }
-  } else {
-    result = type_name(ttype, in_typedef, is_const);
-  }
-
-  return result;
-}
-
-/**
- * Maps a Thrift primitive to a C primitive.
- */
-string t_c_glib_generator::base_type_name(t_type* type) {
-  if (type->is_enum()) {
-    return type_name(type);
-  }
-  if (!type->is_base_type()) {
-    throw std::invalid_argument("Only base types are suppported.");
-  }
-  t_base_type* base_type = reinterpret_cast<t_base_type*>(type);
-  t_base_type::t_base tbase = base_type->get_base();
-  switch (tbase) {
-  case t_base_type::TYPE_VOID:
-    return "void";
-  case t_base_type::TYPE_STRING:
-    if (base_type->is_binary()) {
-      return "GByteArray *";
-    } else {
-      return "gchar *";
-    }
-  case t_base_type::TYPE_BOOL:
-    return "gboolean";
-  case t_base_type::TYPE_I8:
-    return "gint8";
-  case t_base_type::TYPE_I16:
-    return "gint16";
-  case t_base_type::TYPE_I32:
-    return "gint32";
-  case t_base_type::TYPE_I64:
-    return "gint64";
-  case t_base_type::TYPE_DOUBLE:
-    return "gdouble";
-  default:
-    throw std::logic_error("compiler error: no C base type name for base type "
-                           + t_base_type::t_base_name(tbase));
-  }
-}
-
-/**
- * Returns a member of the ThriftType C enumeration in thrift_protocol.h
- * for a Thrift type.
- */
-string t_c_glib_generator::type_to_enum(t_type* type) {
-  type = get_true_type(type);
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "NO T_VOID CONSTRUCT";
-    case t_base_type::TYPE_STRING:
-      return "T_STRING";
-    case t_base_type::TYPE_BOOL:
-      return "T_BOOL";
-    case t_base_type::TYPE_I8:
-      return "T_BYTE";
-    case t_base_type::TYPE_I16:
-      return "T_I16";
-    case t_base_type::TYPE_I32:
-      return "T_I32";
-    case t_base_type::TYPE_I64:
-      return "T_I64";
-    case t_base_type::TYPE_DOUBLE:
-      return "T_DOUBLE";
-    }
-  } else if (type->is_enum()) {
-    return "T_I32";
-  } else if (type->is_struct()) {
-    return "T_STRUCT";
-  } else if (type->is_xception()) {
-    return "T_STRUCT";
-  } else if (type->is_map()) {
-    return "T_MAP";
-  } else if (type->is_set()) {
-    return "T_SET";
-  } else if (type->is_list()) {
-    return "T_LIST";
-  }
-
-  throw "INVALID TYPE IN type_to_enum: " + type->get_name();
-}
-
-/**
- * Returns a Thrift constant formatted as a literal for inclusion in C code.
- */
-string t_c_glib_generator::constant_literal(t_type* type, t_const_value* value) {
-  ostringstream render;
-
-  if (type->is_base_type()) {
-    /* primitives */
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      render << "\"" + value->get_string() + "\"";
-      break;
-    case t_base_type::TYPE_BOOL:
-      render << ((value->get_integer() != 0) ? "TRUE" : "FALSE");
-      break;
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-    case t_base_type::TYPE_I64:
-      render << value->get_integer();
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      render << value->get_double();
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else {
-    t_const_value::t_const_value_type value_type = value->get_type();
-
-    switch (value_type) {
-    case t_const_value::CV_IDENTIFIER:
-      render << value->get_integer();
-      break;
-    case t_const_value::CV_LIST:
-      render << "{ ";
-      {
-        t_type* elem_type = ((t_list*)type)->get_elem_type();
-        const vector<t_const_value*>& list = value->get_list();
-        vector<t_const_value*>::const_iterator list_iter;
-
-        if (list.size() > 0) {
-          list_iter = list.begin();
-          render << constant_literal(elem_type, *list_iter);
-
-          while (++list_iter != list.end()) {
-            render << ", " << constant_literal(elem_type, *list_iter);
-          }
-        }
-      }
-      render << " }";
-      break;
-    case t_const_value::CV_MAP:
-    default:
-      render << "NULL /* not supported */";
-    }
-  }
-
-  return render.str();
-}
-
-/**
- * Returns C code that represents a Thrift constant.
- */
-string t_c_glib_generator::constant_value(string name, t_type* type, t_const_value* value) {
-  ostringstream render;
-
-  if (type->is_base_type()) {
-    /* primitives */
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      render << "g_strdup (\"" + value->get_string() + "\")";
-      break;
-    case t_base_type::TYPE_BOOL:
-      render << ((value->get_integer() != 0) ? 1 : 0);
-      break;
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-      render << value->get_integer();
-      break;
-    case t_base_type::TYPE_I64:
-      render << "G_GINT64_CONSTANT (" << value->get_integer() << ")";
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      if (value->get_type() == t_const_value::CV_INTEGER) {
-        render << value->get_integer();
-      } else {
-        render << value->get_double();
-      }
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else if (type->is_enum()) {
-    render << "(" << type_name(type) << ")" << value->get_integer();
-  } else if (is_complex_type(type)) {
-    render << "(" << this->nspace_lc << to_lower_case(name) << "_constant())";
-  } else {
-    render << "NULL /* not supported */";
-  }
-
-  return render.str();
-}
-
-/**
- * Renders a function signature of the form 'type name(args)'
- *
- * @param tfunction Function definition
- * @return String of rendered function definition
- */
-string t_c_glib_generator::function_signature(t_function* tfunction) {
-  t_type* ttype = tfunction->get_returntype();
-  t_struct* arglist = tfunction->get_arglist();
-  t_struct* xlist = tfunction->get_xceptions();
-  string fname = initial_caps_to_underscores(tfunction->get_name());
-
-  bool has_return = !ttype->is_void();
-  bool has_args = arglist->get_members().size() == 0;
-  bool has_xceptions = xlist->get_members().size() == 0;
-  return "gboolean " + this->nspace_lc + fname + " (" + this->nspace + service_name_ + "If * iface"
-         + (has_return ? ", " + type_name(ttype) + "* _return" : "")
-         + (has_args ? "" : (", " + argument_list(arglist)))
-         + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError ** error)";
-}
-
-/**
- * Renders a field list
- *
- * @param tstruct The struct definition
- * @return Comma sepearated list of all field names in that struct
- */
-string t_c_glib_generator::argument_list(t_struct* tstruct) {
-  string result = "";
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      result += ", ";
-    }
-    result += type_name((*f_iter)->get_type(), false, true) + " " + (*f_iter)->get_name();
-  }
-  return result;
-}
-
-/**
- * Renders mutable exception lists
- *
- * @param tstruct The struct definition
- * @return Comma sepearated list of all field names in that struct
- */
-string t_c_glib_generator::xception_list(t_struct* tstruct) {
-  string result = "";
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      result += ", ";
-    }
-    result += type_name((*f_iter)->get_type(), false, false) + "* " + (*f_iter)->get_name();
-  }
-  return result;
-}
-
-/**
- * Declares a field, including any necessary initialization.
- */
-string t_c_glib_generator::declare_field(t_field* tfield,
-                                         bool init,
-                                         bool pointer,
-                                         bool constant,
-                                         bool reference) {
-  string result = "";
-  if (constant) {
-    result += "const ";
-  }
-  result += type_name(tfield->get_type());
-  if (pointer) {
-    result += "*";
-  }
-  if (reference) {
-    result += "*";
-  }
-  result += " " + tfield->get_name();
-  if (init) {
-    t_type* type = get_true_type(tfield->get_type());
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        break;
-      case t_base_type::TYPE_BOOL:
-      case t_base_type::TYPE_I8:
-      case t_base_type::TYPE_I16:
-      case t_base_type::TYPE_I32:
-      case t_base_type::TYPE_I64:
-        result += " = 0";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        result += " = (gdouble) 0";
-        break;
-      case t_base_type::TYPE_STRING:
-        result += " = NULL";
-        break;
-      default:
-        throw "compiler error: no C intializer for base type " + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      result += " = (" + type_name(type) + ") 0";
-    } else if (type->is_struct() || type->is_container()) {
-      result += " = NULL";
-    }
-  }
-
-  if (!reference) {
-    result += ";";
-  }
-
-  return result;
-}
-
-string t_c_glib_generator::constant_value_with_storage(string fname,
-                                                       t_type* etype,
-                                                       t_const_value* value) {
-  ostringstream render;
-  if (is_numeric(etype)) {
-    render << "    " << type_name(etype) << " *" << fname << " = "
-           << "g_new (" << base_type_name(etype) << ", 1);" << endl
-           << "    *" << fname << " = " << constant_value(fname, (t_type*)etype, value) << ";"
-           << endl;
-  } else {
-    render << "    " << type_name(etype) << " " << fname << " = "
-           << constant_value(fname, (t_type*)etype, value) << ";" << endl;
-  }
-  return render.str();
-}
-
-/**
- * Generates C code that initializes complex constants.
- */
-void t_c_glib_generator::generate_const_initializer(string name,
-                                                    t_type* type,
-                                                    t_const_value* value,
-                                                    bool top_level) {
-  string name_u = initial_caps_to_underscores(name);
-  string name_lc = to_lower_case(name_u);
-  string type_u = initial_caps_to_underscores(type->get_name());
-  string type_uc = to_upper_case(type_u);
-  string maybe_static = top_level ? "" : "static ";
-
-  if (type->is_struct() || type->is_xception()) {
-    const vector<t_field*>& fields = ((t_struct*)type)->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    ostringstream initializers;
-
-    // initialize any constants that may be referenced by this initializer
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      t_type* field_type = NULL;
-      string field_name = "";
-
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field_type = (*f_iter)->get_type();
-          field_name = (*f_iter)->get_name();
-          break;
-        }
-      }
-      if (field_type == NULL) {
-        throw "type error: " + type->get_name() + " has no field "
-          + v_iter->first->get_string();
-      }
-      field_name = tmp(field_name);
-
-      generate_const_initializer(name + "_constant_" + field_name,
-                                 field_type,
-                                 v_iter->second);
-      initializers << "    constant->" << v_iter->first->get_string() << " = "
-                   << constant_value(name + "_constant_" + field_name,
-                                     field_type,
-                                     v_iter->second) << ";" << endl
-                   << "    constant->__isset_" << v_iter->first->get_string()
-                   << " = TRUE;" << endl;
-    }
-
-    // implement the initializer
-    f_types_impl_ << maybe_static << this->nspace << type->get_name() << " *"
-                  << endl
-                  << this->nspace_lc << name_lc << "_constant (void)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << indent() << "static " << this->nspace << type->get_name()
-                  << " *constant = NULL;" << endl
-                  << indent() << "if (constant == NULL)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << indent() << "constant = g_object_new (" << this->nspace_uc
-                  << "TYPE_" << type_uc << ", NULL);" << endl
-                  << initializers.str();
-    scope_down(f_types_impl_);
-
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      t_type* field_type = NULL;
-      string field_name = "";
-
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field_type = (*f_iter)->get_type();
-          field_name = (*f_iter)->get_name();
-          break;
-        }
-      }
-      if (field_type == NULL) {
-        throw "type error: " + type->get_name() + " has no field "
-          + v_iter->first->get_string();
-      }
-      field_name = tmp(field_name);
-    }
-
-    f_types_impl_ << indent() << "return constant;" << endl;
-    scope_down(f_types_impl_);
-    f_types_impl_ << endl;
-  } else if (type->is_list()) {
-    string list_type = "GPtrArray *";
-    string free_func
-        = generate_free_func_from_type(reinterpret_cast<t_list*>(type)->get_elem_type());
-    string list_initializer = "g_ptr_array_new_with_free_func (" + free_func + ");";
-    string list_appender = "g_ptr_array_add";
-    bool list_variable = false;
-
-    t_type* etype = ((t_list*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    ostringstream initializers;
-    ostringstream appenders;
-
-    list_initializer = generate_new_array_from_type(etype);
-    if (etype->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)etype)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot determine array type";
-      case t_base_type::TYPE_BOOL:
-      case t_base_type::TYPE_I8:
-      case t_base_type::TYPE_I16:
-      case t_base_type::TYPE_I32:
-      case t_base_type::TYPE_I64:
-      case t_base_type::TYPE_DOUBLE:
-        list_type = "GArray *";
-        list_appender = "g_array_append_val";
-        list_variable = true;
-        break;
-      case t_base_type::TYPE_STRING:
-        break;
-      default:
-        throw "compiler error: no array info for type";
-      }
-    } else if (etype->is_enum()) {
-      list_type = "GArray *";
-      list_appender = "g_array_append_val";
-      list_variable = true;
-    }
-
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string fname = tmp(name);
-
-      generate_const_initializer(fname, etype, (*v_iter));
-      if (list_variable) {
-        initializers << "    " << type_name(etype) << " " << fname << " = "
-                     << constant_value(fname, (t_type*)etype, (*v_iter)) << ";"
-                     << endl;
-        appenders << "    " << list_appender << "(constant, " << fname << ");"
-                  << endl;
-      } else {
-        appenders << "    " << list_appender << "(constant, "
-                  << constant_value(fname, (t_type*)etype, (*v_iter)) << ");"
-                  << endl;
-      }
-    }
-
-    f_types_impl_ << maybe_static << list_type << endl
-                  << this->nspace_lc << name_lc << "_constant (void)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << indent() << "static " << list_type << " constant = NULL;"
-                  << endl
-                  << indent() << "if (constant == NULL)" << endl;
-    scope_up(f_types_impl_);
-    if (!initializers.str().empty()) {
-      f_types_impl_ << initializers.str()
-                    << endl;
-    }
-    f_types_impl_ << indent() << "constant = " << list_initializer << endl
-                  << appenders.str();
-    scope_down(f_types_impl_);
-    f_types_impl_ << indent() << "return constant;" << endl;
-    scope_down(f_types_impl_);
-    f_types_impl_ << endl;
-  } else if (type->is_set()) {
-    t_type* etype = ((t_set*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    ostringstream initializers;
-    ostringstream appenders;
-
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string fname = tmp(name);
-      string ptr = is_numeric(etype) ? "*" : "";
-      generate_const_initializer(fname, etype, (*v_iter));
-      initializers << constant_value_with_storage(fname, (t_type*)etype, *v_iter);
-      appenders << "    g_hash_table_insert (constant, " << fname << ", 0);" << endl;
-    }
-
-    f_types_impl_ << maybe_static << "GHashTable *" << endl
-                  << this->nspace_lc << name_lc << "_constant (void)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << indent() << "static GHashTable *constant = NULL;" << endl
-                  << indent() << "if (constant == NULL)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << initializers.str() << endl
-                  << indent() << "constant = " << generate_new_hash_from_type(etype, NULL) << endl
-                  << appenders.str();
-    scope_down(f_types_impl_);
-    f_types_impl_ << indent() << "return constant;" << endl;
-    scope_down(f_types_impl_);
-    f_types_impl_ << endl;
-  } else if (type->is_map()) {
-    t_type* ktype = ((t_map*)type)->get_key_type();
-    t_type* vtype = ((t_map*)type)->get_val_type();
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    ostringstream initializers;
-    ostringstream appenders;
-
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string fname = tmp(name);
-      string kname = fname + "key";
-      string vname = fname + "val";
-      generate_const_initializer(kname, ktype, v_iter->first);
-      generate_const_initializer(vname, vtype, v_iter->second);
-
-      initializers << constant_value_with_storage(kname, (t_type*)ktype, v_iter->first);
-      initializers << constant_value_with_storage(vname, (t_type*)vtype, v_iter->second);
-      appenders << "    g_hash_table_insert (constant, " << kname << ", " << vname << ");" << endl;
-    }
-
-    f_types_impl_ << maybe_static << "GHashTable *" << endl
-                  << this->nspace_lc << name_lc << "_constant (void)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << indent() << "static GHashTable *constant = NULL;" << endl
-                  << indent() << "if (constant == NULL)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << initializers.str() << endl
-                  << indent() << "constant = " << generate_new_hash_from_type(ktype, vtype) << endl
-                  << appenders.str();
-    scope_down(f_types_impl_);
-    f_types_impl_ << indent() << "return constant;" << endl;
-    scope_down(f_types_impl_);
-    f_types_impl_ << endl;
-  }
-}
-
-/**
- * Generates helper classes for a service, consisting of a ThriftStruct subclass
- * for the arguments to and the result from each method.
- *
- * @param tservice The service for which to generate helper classes
- */
-void t_c_glib_generator::generate_service_helpers(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator function_iter;
-
-  // Iterate through the service's methods
-  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) {
-    string function_name = (*function_iter)->get_name();
-    t_struct* arg_list = (*function_iter)->get_arglist();
-    string arg_list_name_orig = arg_list->get_name();
-
-    // Generate the arguments class
-    arg_list->set_name(tservice->get_name() + underscores_to_initial_caps(function_name) + "Args");
-    generate_struct(arg_list);
-
-    arg_list->set_name(arg_list_name_orig);
-
-    // Generate the result class
-    if (!(*function_iter)->is_oneway()) {
-      t_struct result(program_,
-                      tservice->get_name() + underscores_to_initial_caps(function_name) + "Result");
-      t_field success((*function_iter)->get_returntype(), "success", 0);
-      success.set_req(t_field::T_OPTIONAL);
-      if (!(*function_iter)->get_returntype()->is_void()) {
-        result.append(&success);
-      }
-
-      t_struct* xs = (*function_iter)->get_xceptions();
-      const vector<t_field*>& fields = xs->get_members();
-      vector<t_field*>::const_iterator field_iter;
-      for (field_iter = fields.begin(); field_iter != fields.end(); ++field_iter) {
-        (*field_iter)->set_req(t_field::T_OPTIONAL);
-        result.append(*field_iter);
-      }
-
-      generate_struct(&result);
-    }
-  }
-}
-
-/**
- * Generates C code that represents a Thrift service client.
- */
-void t_c_glib_generator::generate_service_client(t_service* tservice) {
-  /* get some C friendly service names */
-  string service_name_lc = to_lower_case(initial_caps_to_underscores(service_name_));
-  string service_name_uc = to_upper_case(service_name_lc);
-
-  string parent_service_name;
-  string parent_service_name_lc;
-  string parent_service_name_uc;
-
-  string parent_class_name = "GObject";
-  string parent_type_name = "G_TYPE_OBJECT";
-
-  // The service this service extends, or NULL if it extends no
-  // service
-  t_service* extends_service = tservice->get_extends();
-  if (extends_service) {
-    // The name of the parent service
-    parent_service_name = extends_service->get_name();
-    parent_service_name_lc = to_lower_case(initial_caps_to_underscores(parent_service_name));
-    parent_service_name_uc = to_upper_case(parent_service_name_lc);
-
-    // The names of the client class' parent class and type
-    parent_class_name = this->nspace + parent_service_name + "Client";
-    parent_type_name = this->nspace_uc + "TYPE_" + parent_service_name_uc + "_CLIENT";
-  }
-
-  // The base service (the topmost in the "extends" hierarchy), on
-  // whose client class the "input_protocol" and "output_protocol"
-  // properties are defined
-  t_service* base_service = tservice;
-  while (base_service->get_extends()) {
-    base_service = base_service->get_extends();
-  }
-
-  string base_service_name = base_service->get_name();
-  string base_service_name_lc = to_lower_case(initial_caps_to_underscores(base_service_name));
-  string base_service_name_uc = to_upper_case(base_service_name_lc);
-
-  // Generate the client interface dummy object in the header.
-  f_header_ << "/* " << service_name_ << " service interface */" << endl << "typedef struct _"
-            << this->nspace << service_name_ << "If " << this->nspace << service_name_ << "If; "
-            << " /* dummy object */" << endl << endl;
-
-  // Generate the client interface object in the header.
-  f_header_ << "struct _" << this->nspace << service_name_ << "IfInterface" << endl << "{" << endl
-            << "  GTypeInterface parent;" << endl << endl;
-
-  /* write out the functions for this interface */
-  indent_up();
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    /* make the function name C friendly */
-    string funname = initial_caps_to_underscores((*f_iter)->get_name());
-    t_type* ttype = (*f_iter)->get_returntype();
-    t_struct* arglist = (*f_iter)->get_arglist();
-    t_struct* xlist = (*f_iter)->get_xceptions();
-    bool has_return = !ttype->is_void();
-    bool has_args = arglist->get_members().size() == 0;
-    bool has_xceptions = xlist->get_members().size() == 0;
-
-    string params = "(" + this->nspace + service_name_ + "If *iface"
-                    + (has_return ? ", " + type_name(ttype) + "* _return" : "")
-                    + (has_args ? "" : (", " + argument_list(arglist)))
-                    + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError **error)";
-
-    indent(f_header_) << "gboolean (*" << funname << ") " << params << ";" << endl;
-  }
-  indent_down();
-
-  f_header_ << "};" << endl << "typedef struct _" << this->nspace << service_name_ << "IfInterface "
-            << this->nspace << service_name_ << "IfInterface;" << endl << endl;
-
-  // generate all the interface boilerplate
-  f_header_ << "GType " << this->nspace_lc << service_name_lc << "_if_get_type (void);" << endl
-            << "#define " << this->nspace_uc << "TYPE_" << service_name_uc << "_IF "
-            << "(" << this->nspace_lc << service_name_lc << "_if_get_type())" << endl << "#define "
-            << this->nspace_uc << service_name_uc << "_IF(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_IF, " << this->nspace << service_name_ << "If))" << endl
-            << "#define " << this->nspace_uc << "IS_" << service_name_uc << "_IF(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_IF))" << endl << "#define " << this->nspace_uc
-            << service_name_uc << "_IF_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), "
-            << this->nspace_uc << "TYPE_" << service_name_uc << "_IF, " << this->nspace
-            << service_name_ << "IfInterface))" << endl << endl;
-
-  // write out all the interface function prototypes
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    /* make the function name C friendly */
-    string funname = initial_caps_to_underscores((*f_iter)->get_name());
-    t_type* ttype = (*f_iter)->get_returntype();
-    t_struct* arglist = (*f_iter)->get_arglist();
-    t_struct* xlist = (*f_iter)->get_xceptions();
-    bool has_return = !ttype->is_void();
-    bool has_args = arglist->get_members().size() == 0;
-    bool has_xceptions = xlist->get_members().size() == 0;
-
-    string params = "(" + this->nspace + service_name_ + "If *iface"
-                    + (has_return ? ", " + type_name(ttype) + "* _return" : "")
-                    + (has_args ? "" : (", " + argument_list(arglist)))
-                    + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError **error)";
-
-    f_header_ << "gboolean " << this->nspace_lc << service_name_lc << "_if_" << funname << " "
-              << params << ";" << endl;
-  }
-  f_header_ << endl;
-
-  // Generate the client object instance definition in the header.
-  f_header_ << "/* " << service_name_ << " service client */" << endl << "struct _" << this->nspace
-            << service_name_ << "Client" << endl << "{" << endl << "  " << parent_class_name
-            << " parent;" << endl;
-  if (!extends_service) {
-    // Define "input_protocol" and "output_protocol" properties only
-    // for base services; child service-client classes will inherit
-    // these
-    f_header_ << endl << "  ThriftProtocol *input_protocol;" << endl
-              << "  ThriftProtocol *output_protocol;" << endl;
-  }
-  f_header_ << "};" << endl << "typedef struct _" << this->nspace << service_name_ << "Client "
-            << this->nspace << service_name_ << "Client;" << endl << endl;
-
-  // Generate the class definition in the header.
-  f_header_ << "struct _" << this->nspace << service_name_ << "ClientClass" << endl << "{" << endl
-            << "  " << parent_class_name << "Class parent;" << endl << "};" << endl
-            << "typedef struct _" << this->nspace << service_name_ << "ClientClass " << this->nspace
-            << service_name_ << "ClientClass;" << endl << endl;
-
-  // Create all the GObject boilerplate
-  f_header_ << "GType " << this->nspace_lc << service_name_lc << "_client_get_type (void);" << endl
-            << "#define " << this->nspace_uc << "TYPE_" << service_name_uc << "_CLIENT "
-            << "(" << this->nspace_lc << service_name_lc << "_client_get_type())" << endl
-            << "#define " << this->nspace_uc << service_name_uc << "_CLIENT(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_CLIENT, " << this->nspace << service_name_ << "Client))" << endl
-            << "#define " << this->nspace_uc << service_name_uc << "_CLIENT_CLASS(c) "
-            << "(G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "TYPE_" << service_name_uc
-            << "_CLIENT, " << this->nspace << service_name_ << "ClientClass))" << endl << "#define "
-            << this->nspace_uc << service_name_uc << "_IS_CLIENT(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_CLIENT))" << endl << "#define " << this->nspace_uc
-            << service_name_uc << "_IS_CLIENT_CLASS(c) "
-            << "(G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc << "TYPE_" << service_name_uc
-            << "_CLIENT))" << endl << "#define " << this->nspace_uc << service_name_uc
-            << "_CLIENT_GET_CLASS(obj) "
-            << "(G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_CLIENT, " << this->nspace << service_name_ << "ClientClass))"
-            << endl << endl;
-
-  /* write out the function prototypes */
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    /* make the function name C friendly */
-    string funname = to_lower_case(initial_caps_to_underscores((*f_iter)->get_name()));
-
-    t_function service_function((*f_iter)->get_returntype(),
-                                service_name_lc + string("_client_") + funname,
-                                (*f_iter)->get_arglist(),
-                                (*f_iter)->get_xceptions());
-    indent(f_header_) << function_signature(&service_function) << ";" << endl;
-
-    t_function send_function(g_type_void,
-                             service_name_lc + string("_client_send_") + funname,
-                             (*f_iter)->get_arglist());
-    indent(f_header_) << function_signature(&send_function) << ";" << endl;
-
-    // implement recv if not a oneway service
-    if (!(*f_iter)->is_oneway()) {
-      t_struct noargs(program_);
-      t_function recv_function((*f_iter)->get_returntype(),
-                               service_name_lc + string("_client_recv_") + funname,
-                               &noargs,
-                               (*f_iter)->get_xceptions());
-      indent(f_header_) << function_signature(&recv_function) << ";" << endl;
-    }
-  }
-
-  /* write out the get/set function prototypes */
-  f_header_ << "void " + service_name_lc + "_client_set_property (GObject *object, guint "
-                                           "property_id, const GValue *value, GParamSpec *pspec);"
-            << endl;
-  f_header_ << "void " + service_name_lc + "_client_get_property (GObject *object, guint "
-                                           "property_id, GValue *value, GParamSpec *pspec);"
-            << endl;
-
-  f_header_ << endl;
-  // end of header code
-
-  // Generate interface method implementations
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    /* make the function name C friendly */
-    string funname = initial_caps_to_underscores((*f_iter)->get_name());
-    t_type* ttype = (*f_iter)->get_returntype();
-    t_struct* arglist = (*f_iter)->get_arglist();
-    t_struct* xlist = (*f_iter)->get_xceptions();
-    bool has_return = !ttype->is_void();
-    bool has_args = arglist->get_members().size() == 0;
-    bool has_xceptions = xlist->get_members().size() == 0;
-
-    string params = "(" + this->nspace + service_name_ + "If *iface"
-                    + (has_return ? ", " + type_name(ttype) + "* _return" : "")
-                    + (has_args ? "" : (", " + argument_list(arglist)))
-                    + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError **error)";
-
-    string params_without_type = string("iface, ") + (has_return ? "_return, " : "");
-
-    const vector<t_field*>& fields = arglist->get_members();
-    vector<t_field*>::const_iterator f_iter_field;
-    for (f_iter_field = fields.begin(); f_iter_field != fields.end(); ++f_iter_field) {
-      params_without_type += (*f_iter_field)->get_name();
-      params_without_type += ", ";
-    }
-
-    const vector<t_field*>& xceptions = xlist->get_members();
-    vector<t_field*>::const_iterator x_iter;
-    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-      params_without_type += (*x_iter)->get_name();
-      params_without_type += ", ";
-    }
-
-    f_service_ << "gboolean" << endl << this->nspace_lc << service_name_lc << "_if_" << funname
-               << " " << params << endl << "{" << endl << "  return " << this->nspace_uc
-               << service_name_uc << "_IF_GET_INTERFACE (iface)->" << funname << " ("
-               << params_without_type << "error);" << endl << "}" << endl << endl;
-  }
-
-  // Generate interface boilerplate
-  f_service_ << "GType" << endl << this->nspace_lc << service_name_lc << "_if_get_type (void)"
-             << endl << "{" << endl << "  static GType type = 0;" << endl << "  if (type == 0)"
-             << endl << "  {" << endl << "    static const GTypeInfo type_info =" << endl << "    {"
-             << endl << "      sizeof (" << this->nspace << service_name_ << "IfInterface)," << endl
-             << "      NULL,  /* base_init */" << endl << "      NULL,  /* base_finalize */" << endl
-             << "      NULL,  /* class_init */" << endl << "      NULL,  /* class_finalize */"
-             << endl << "      NULL,  /* class_data */" << endl
-             << "      0,     /* instance_size */" << endl << "      0,     /* n_preallocs */"
-             << endl << "      NULL,  /* instance_init */" << endl
-             << "      NULL   /* value_table */" << endl << "    };" << endl
-             << "    type = g_type_register_static (G_TYPE_INTERFACE," << endl
-             << "                                   \"" << this->nspace << service_name_ << "If\","
-             << endl << "                                   &type_info, 0);" << endl << "  }"
-             << endl << "  return type;" << endl << "}" << endl << endl;
-
-  // Generate client boilerplate
-  f_service_ << "static void " << endl << this->nspace_lc << service_name_lc
-             << "_if_interface_init (" << this->nspace << service_name_ << "IfInterface *iface);"
-             << endl << endl << "G_DEFINE_TYPE_WITH_CODE (" << this->nspace << service_name_
-             << "Client, " << this->nspace_lc << service_name_lc << "_client," << endl
-             << "                         " << parent_type_name << ", " << endl
-             << "                         G_IMPLEMENT_INTERFACE (" << this->nspace_uc << "TYPE_"
-             << service_name_uc << "_IF," << endl
-             << "                                                " << this->nspace_lc
-             << service_name_lc << "_if_interface_init))" << endl << endl;
-
-  // Generate property-related code only for base services---child
-  // service-client classes have only properties inherited from their
-  // parent class
-  if (!extends_service) {
-    // Generate client properties
-    f_service_ << "enum _" << this->nspace << service_name_ << "ClientProperties" << endl << "{"
-               << endl << "  PROP_0," << endl << "  PROP_" << this->nspace_uc << service_name_uc
-               << "_CLIENT_INPUT_PROTOCOL," << endl << "  PROP_" << this->nspace_uc
-               << service_name_uc << "_CLIENT_OUTPUT_PROTOCOL" << endl << "};" << endl << endl;
-
-    // generate property setter
-    f_service_ << "void" << endl << this->nspace_lc << service_name_lc << "_client_set_property ("
-               << "GObject *object, guint property_id, const GValue *value, "
-               << "GParamSpec *pspec)" << endl << "{" << endl << "  " << this->nspace
-               << service_name_ << "Client *client = " << this->nspace_uc << service_name_uc
-               << "_CLIENT (object);" << endl << endl << "  THRIFT_UNUSED_VAR (pspec);" << endl
-               << endl << "  switch (property_id)" << endl << "  {" << endl << "    case PROP_"
-               << this->nspace_uc << service_name_uc << "_CLIENT_INPUT_PROTOCOL:" << endl
-               << "      client->input_protocol = g_value_get_object (value);" << endl
-               << "      break;" << endl << "    case PROP_" << this->nspace_uc << service_name_uc
-               << "_CLIENT_OUTPUT_PROTOCOL:" << endl
-               << "      client->output_protocol = g_value_get_object (value);" << endl
-               << "      break;" << endl << "  }" << endl << "}" << endl << endl;
-
-    // generate property getter
-    f_service_ << "void" << endl << this->nspace_lc << service_name_lc << "_client_get_property ("
-               << "GObject *object, guint property_id, GValue *value, "
-               << "GParamSpec *pspec)" << endl << "{" << endl << "  " << this->nspace
-               << service_name_ << "Client *client = " << this->nspace_uc << service_name_uc
-               << "_CLIENT (object);" << endl << endl << "  THRIFT_UNUSED_VAR (pspec);" << endl
-               << endl << "  switch (property_id)" << endl << "  {" << endl << "    case PROP_"
-               << this->nspace_uc << service_name_uc << "_CLIENT_INPUT_PROTOCOL:" << endl
-               << "      g_value_set_object (value, client->input_protocol);" << endl
-               << "      break;" << endl << "    case PROP_" << this->nspace_uc << service_name_uc
-               << "_CLIENT_OUTPUT_PROTOCOL:" << endl
-               << "      g_value_set_object (value, client->output_protocol);" << endl
-               << "      break;" << endl << "  }" << endl << "}" << endl << endl;
-  }
-
-  // Generate client method implementations
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    string name = (*f_iter)->get_name();
-    string funname = initial_caps_to_underscores(name);
-
-    // Get the struct of function call params and exceptions
-    t_struct* arg_struct = (*f_iter)->get_arglist();
-
-    // Function for sending
-    t_function send_function(g_type_void,
-                             service_name_lc + string("_client_send_") + funname,
-                             (*f_iter)->get_arglist());
-
-    // Open the send function
-    indent(f_service_) << function_signature(&send_function) << endl;
-    scope_up(f_service_);
-
-    string reqType = (*f_iter)->is_oneway() ? "T_ONEWAY" : "T_CALL";
-
-    // Serialize the request
-    f_service_ << indent() << "gint32 cseqid = 0;" << endl << indent()
-               << "ThriftProtocol * protocol = " << this->nspace_uc << base_service_name_uc
-               << "_CLIENT (iface)->output_protocol;" << endl << endl << indent()
-               << "if (thrift_protocol_write_message_begin (protocol, \"" << name << "\", "
-               << reqType << ", cseqid, error) < 0)" << endl << indent() << "  return FALSE;"
-               << endl << endl;
-
-    generate_struct_writer(f_service_, arg_struct, "", "", false);
-
-    f_service_ << indent() << "if (thrift_protocol_write_message_end (protocol, error) < 0)" << endl
-               << indent() << "  return FALSE;" << endl << indent()
-               << "if (!thrift_transport_flush (protocol->transport, error))" << endl << indent()
-               << "  return FALSE;" << endl << indent()
-               << "if (!thrift_transport_write_end (protocol->transport, error))" << endl
-               << indent() << "  return FALSE;" << endl << endl << indent() << "return TRUE;"
-               << endl;
-
-    scope_down(f_service_);
-    f_service_ << endl;
-
-    // Generate recv function only if not an async function
-    if (!(*f_iter)->is_oneway()) {
-      t_struct noargs(program_);
-      t_function recv_function((*f_iter)->get_returntype(),
-                               service_name_lc + string("_client_recv_") + funname,
-                               &noargs,
-                               (*f_iter)->get_xceptions());
-      // Open function
-      indent(f_service_) << function_signature(&recv_function) << endl;
-      scope_up(f_service_);
-
-      f_service_ << indent() << "gint32 rseqid;" << endl
-                 << indent() << "gchar * fname = NULL;" << endl
-                 << indent() << "ThriftMessageType mtype;" << endl
-                 << indent() << "ThriftProtocol * protocol = "
-                 << this->nspace_uc << base_service_name_uc
-                 << "_CLIENT (iface)->input_protocol;" << endl
-                 << indent() << "ThriftApplicationException *xception;" << endl
-                 << endl
-                 << indent() << "if (thrift_protocol_read_message_begin "
-                    "(protocol, &fname, &mtype, &rseqid, error) < 0) {" << endl;
-      indent_up();
-      f_service_ << indent() << "if (fname) g_free (fname);" << endl
-                 << indent() << "return FALSE;" << endl;
-      indent_down();
-      f_service_ << indent() << "}" << endl
-                 << endl
-                 << indent() << "if (mtype == T_EXCEPTION) {" << endl;
-      indent_up();
-      f_service_ << indent() << "if (fname) g_free (fname);" << endl
-                 << indent() << "xception = g_object_new "
-                    "(THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);" << endl
-                 << indent() << "thrift_struct_read (THRIFT_STRUCT (xception), "
-                    "protocol, NULL);" << endl
-                 << indent() << "thrift_protocol_read_message_end "
-                    "(protocol, NULL);" << endl
-                 << indent() << "thrift_transport_read_end "
-                    "(protocol->transport, NULL);" << endl
-                 << indent() << "g_set_error (error, "
-                    "THRIFT_APPLICATION_EXCEPTION_ERROR,xception->type, "
-                    "\"application error: %s\", xception->message);" << endl
-                 << indent() << "g_object_unref (xception);" << endl
-                 << indent() << "return FALSE;" << endl;
-      indent_down();
-      f_service_ << indent() << "} else if (mtype != T_REPLY) {" << endl;
-      indent_up();
-      f_service_ << indent() << "if (fname) g_free (fname);" << endl
-                 << indent() << "thrift_protocol_skip (protocol, T_STRUCT, "
-                    "NULL);" << endl
-                 << indent() << "thrift_protocol_read_message_end (protocol, "
-                    "NULL);" << endl
-                 << indent() << "thrift_transport_read_end ("
-                    "protocol->transport, NULL);" << endl
-                 << indent() << "g_set_error (error, "
-                    "THRIFT_APPLICATION_EXCEPTION_ERROR, "
-                    "THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, "
-                    "\"invalid message type %d, expected T_REPLY\", mtype);"
-                 << endl
-                 << indent() << "return FALSE;" << endl;
-      indent_down();
-      f_service_ << indent() << "} else if (strncmp (fname, \"" << name
-                 << "\", " << name.length() << ") != 0) {" << endl;
-      indent_up();
-      f_service_ << indent() << "thrift_protocol_skip (protocol, T_STRUCT, "
-                    "NULL);" << endl
-                 << indent() << "thrift_protocol_read_message_end (protocol,"
-                    "error);" << endl
-                 << indent() << "thrift_transport_read_end ("
-                    "protocol->transport, error);" << endl
-                 << indent() << "g_set_error (error, "
-                    "THRIFT_APPLICATION_EXCEPTION_ERROR, "
-                    "THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, "
-                    "\"wrong method name %s, expected " << name
-                    << "\", fname);" << endl
-                 << indent() << "if (fname) g_free (fname);" << endl
-                 << indent() << "return FALSE;" << endl;
-      indent_down();
-      f_service_ << indent() << "}" << endl
-                 << indent() << "if (fname) g_free (fname);" << endl
-                 << endl;
-
-      t_struct* xs = (*f_iter)->get_xceptions();
-      const std::vector<t_field*>& xceptions = xs->get_members();
-      vector<t_field*>::const_iterator x_iter;
-
-      {
-        t_struct result(program_, tservice->get_name() + "_" + (*f_iter)->get_name() + "_result");
-        t_field success((*f_iter)->get_returntype(), "*_return", 0);
-        if (!(*f_iter)->get_returntype()->is_void()) {
-          result.append(&success);
-        }
-
-        // add readers for exceptions, dereferencing the pointer.
-        for (x_iter = xceptions.begin(); x_iter != xceptions.end(); x_iter++) {
-          t_field* xception = new t_field((*x_iter)->get_type(),
-                                          "*" + (*x_iter)->get_name(),
-                                          (*x_iter)->get_key());
-          result.append(xception);
-        }
-
-        generate_struct_reader(f_service_, &result, "", "", false);
-      }
-
-      f_service_ << indent() << "if (thrift_protocol_read_message_end (protocol, error) < 0)"
-                 << endl << indent() << "  return FALSE;" << endl << endl << indent()
-                 << "if (!thrift_transport_read_end (protocol->transport, error))" << endl
-                 << indent() << "  return FALSE;" << endl << endl;
-
-      // copy over any throw exceptions and return failure
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); x_iter++) {
-        f_service_ << indent() << "if (*" << (*x_iter)->get_name() << " != NULL)" << endl
-                   << indent() << "{" << endl << indent() << "    g_set_error (error, "
-                   << this->nspace_uc
-                   << to_upper_case(initial_caps_to_underscores((*x_iter)->get_type()->get_name()))
-                   << "_ERROR, " << this->nspace_uc
-                   << to_upper_case(initial_caps_to_underscores((*x_iter)->get_type()->get_name()))
-                   << "_ERROR_CODE, \"" << (*x_iter)->get_type()->get_name() << "\");" << endl
-                   << indent() << "    return FALSE;" << endl << indent() << "}" << endl;
-      }
-      // Close function
-      indent(f_service_) << "return TRUE;" << endl;
-      scope_down(f_service_);
-      f_service_ << endl;
-    }
-
-    // Open function
-    t_function service_function((*f_iter)->get_returntype(),
-                                service_name_lc + string("_client_") + funname,
-                                (*f_iter)->get_arglist(),
-                                (*f_iter)->get_xceptions());
-    indent(f_service_) << function_signature(&service_function) << endl;
-    scope_up(f_service_);
-
-    // wrap each function
-    f_service_ << indent() << "if (!" << this->nspace_lc << service_name_lc << "_client_send_"
-               << funname << " (iface";
-
-    // Declare the function arguments
-    const vector<t_field*>& fields = arg_struct->get_members();
-    vector<t_field*>::const_iterator fld_iter;
-    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-      f_service_ << ", " << (*fld_iter)->get_name();
-    }
-    f_service_ << ", error))" << endl << indent() << "  return FALSE;" << endl;
-
-    // if not oneway, implement recv
-    if (!(*f_iter)->is_oneway()) {
-      string ret = (*f_iter)->get_returntype()->is_void() ? "" : "_return, ";
-
-      const vector<t_field*>& xceptions = (*f_iter)->get_xceptions()->get_members();
-      vector<t_field*>::const_iterator x_iter;
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-        ret += (*x_iter)->get_name();
-        ret += ", ";
-      }
-
-      f_service_ << indent() << "if (!" << this->nspace_lc << service_name_lc << "_client_recv_"
-                 << funname << " (iface, " << ret << "error))" << endl << indent()
-                 << "  return FALSE;" << endl;
-    }
-
-    // return TRUE which means all functions were called OK
-    indent(f_service_) << "return TRUE;" << endl;
-    scope_down(f_service_);
-    f_service_ << endl;
-  }
-
-  // create the interface initializer
-  f_service_ << "static void" << endl
-             << this->nspace_lc << service_name_lc << "_if_interface_init ("
-             << this->nspace << service_name_ << "IfInterface *iface)" << endl;
-  scope_up(f_service_);
-  if (functions.size() > 0) {
-    for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-      /* make the function name C friendly */
-      string funname = initial_caps_to_underscores((*f_iter)->get_name());
-
-      f_service_ << indent() << "iface->" << funname << " = " << this->nspace_lc
-                 << service_name_lc << "_client_" << funname << ";" << endl;
-    }
-  }
-  else {
-    f_service_ << indent() << "THRIFT_UNUSED_VAR (iface);" << endl;
-  }
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // create the client instance initializer
-  f_service_ << "static void" << endl
-             << this->nspace_lc << service_name_lc << "_client_init ("
-             << this->nspace << service_name_ << "Client *client)" << endl;
-  scope_up(f_service_);
-  if (!extends_service) {
-    f_service_ << indent() << "client->input_protocol = NULL;" << endl
-               << indent() << "client->output_protocol = NULL;" << endl;
-  }
-  else {
-    f_service_ << indent() << "THRIFT_UNUSED_VAR (client);" << endl;
-  }
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // create the client class initializer
-  f_service_ << "static void" << endl << this->nspace_lc << service_name_lc
-             << "_client_class_init (" << this->nspace << service_name_ << "ClientClass *cls)"
-             << endl << "{" << endl;
-  if (!extends_service) {
-    f_service_ << "  GObjectClass *gobject_class = G_OBJECT_CLASS (cls);" << endl
-               << "  GParamSpec *param_spec;" << endl << endl
-               << "  gobject_class->set_property = " << this->nspace_lc << service_name_lc
-               << "_client_set_property;" << endl
-               << "  gobject_class->get_property = " << this->nspace_lc << service_name_lc
-               << "_client_get_property;" << endl << endl
-               << "  param_spec = g_param_spec_object (\"input_protocol\"," << endl
-               << "                                    \"input protocol (construct)\"," << endl
-               << "                                    \"Set the client input protocol\"," << endl
-               << "                                    THRIFT_TYPE_PROTOCOL," << endl
-               << "                                    G_PARAM_READWRITE);" << endl
-               << "  g_object_class_install_property (gobject_class," << endl
-               << "                                   PROP_" << this->nspace_uc << service_name_uc
-               << "_CLIENT_INPUT_PROTOCOL, param_spec);" << endl << endl
-               << "  param_spec = g_param_spec_object (\"output_protocol\"," << endl
-               << "                                    \"output protocol (construct)\"," << endl
-               << "                                    \"Set the client output protocol\"," << endl
-               << "                                    THRIFT_TYPE_PROTOCOL," << endl
-               << "                                    G_PARAM_READWRITE);" << endl
-               << "  g_object_class_install_property (gobject_class," << endl
-               << "                                   PROP_" << this->nspace_uc << service_name_uc
-               << "_CLIENT_OUTPUT_PROTOCOL, param_spec);" << endl;
-  }
-  else {
-    f_service_ << "  THRIFT_UNUSED_VAR (cls);" << endl;
-  }
-  f_service_ << "}" << endl << endl;
-}
-
-/**
- * Generates C code that represents a Thrift service handler.
- *
- * @param tservice The service for which to generate a handler.
- */
-void t_c_glib_generator::generate_service_handler(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator function_iter;
-
-  string service_name_lc = to_lower_case(initial_caps_to_underscores(service_name_));
-  string service_name_uc = to_upper_case(service_name_lc);
-
-  string class_name = this->nspace + service_name_ + "Handler";
-  string class_name_lc = to_lower_case(initial_caps_to_underscores(class_name));
-  string class_name_uc = to_upper_case(class_name_lc);
-
-  string parent_class_name;
-  string parent_type_name;
-
-  string args_indent;
-
-  // The service this service extends, or NULL if it extends no service
-  t_service* extends_service = tservice->get_extends();
-
-  // Determine the name of our parent service (if any) and the handler class'
-  // parent class name and type
-  if (extends_service) {
-    string parent_service_name = extends_service->get_name();
-    string parent_service_name_lc = to_lower_case(initial_caps_to_underscores(parent_service_name));
-    string parent_service_name_uc = to_upper_case(parent_service_name_lc);
-
-    parent_class_name = this->nspace + parent_service_name + "Handler";
-    parent_type_name = this->nspace_uc + "TYPE_" + parent_service_name_uc + "_HANDLER";
-  } else {
-    parent_class_name = "GObject";
-    parent_type_name = "G_TYPE_OBJECT";
-  }
-
-  // Generate the handler class' definition in the header file
-
-  // Generate the handler instance definition
-  f_header_ << "/* " << service_name_ << " handler (abstract base class) */" << endl << "struct _"
-            << class_name << endl << "{" << endl;
-  indent_up();
-  f_header_ << indent() << parent_class_name << " parent;" << endl;
-  indent_down();
-  f_header_ << "};" << endl << "typedef struct _" << class_name << " " << class_name << ";" << endl
-            << endl;
-
-  // Generate the handler class definition, including its class members
-  // (methods)
-  f_header_ << "struct _" << class_name << "Class" << endl << "{" << endl;
-  indent_up();
-  f_header_ << indent() << parent_class_name << "Class parent;" << endl << endl;
-
-  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) {
-    string method_name = initial_caps_to_underscores((*function_iter)->get_name());
-    t_type* return_type = (*function_iter)->get_returntype();
-    t_struct* arg_list = (*function_iter)->get_arglist();
-    t_struct* x_list = (*function_iter)->get_xceptions();
-    bool has_return = !return_type->is_void();
-    bool has_args = arg_list->get_members().size() == 0;
-    bool has_xceptions = x_list->get_members().size() == 0;
-
-    string params = "(" + this->nspace + service_name_ + "If *iface"
-                    + (has_return ? ", " + type_name(return_type) + "* _return" : "")
-                    + (has_args ? "" : (", " + argument_list(arg_list)))
-                    + (has_xceptions ? "" : (", " + xception_list(x_list))) + ", GError **error)";
-
-    indent(f_header_) << "gboolean (*" << method_name << ") " << params << ";" << endl;
-  }
-  indent_down();
-
-  f_header_ << "};" << endl << "typedef struct _" << class_name << "Class " << class_name
-            << "Class;" << endl << endl;
-
-  // Generate the remaining header boilerplate
-  f_header_ << "GType " << class_name_lc << "_get_type (void);" << endl << "#define "
-            << this->nspace_uc << "TYPE_" << service_name_uc << "_HANDLER "
-            << "(" << class_name_lc << "_get_type())" << endl << "#define " << class_name_uc
-            << "(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_HANDLER, " << class_name << "))" << endl << "#define "
-            << this->nspace_uc << "IS_" << service_name_uc << "_HANDLER(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_HANDLER))" << endl << "#define " << class_name_uc
-            << "_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_HANDLER, " << class_name << "Class))" << endl << "#define "
-            << this->nspace_uc << "IS_" << service_name_uc << "_HANDLER_CLASS(c) "
-            << "(G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc << "TYPE_" << service_name_uc
-            << "_HANDLER))" << endl << "#define " << this->nspace_uc << service_name_uc
-            << "_HANDLER_GET_CLASS(obj) "
-            << "(G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_HANDLER, " << class_name << "Class))" << endl << endl;
-
-  // Generate the handler class' method definitions
-  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) {
-    string method_name = initial_caps_to_underscores((*function_iter)->get_name());
-    t_type* return_type = (*function_iter)->get_returntype();
-    t_struct* arg_list = (*function_iter)->get_arglist();
-    t_struct* x_list = (*function_iter)->get_xceptions();
-    bool has_return = !return_type->is_void();
-    bool has_args = arg_list->get_members().size() == 0;
-    bool has_xceptions = x_list->get_members().size() == 0;
-
-    string params = "(" + this->nspace + service_name_ + "If *iface"
-                    + (has_return ? ", " + type_name(return_type) + "* _return" : "")
-                    + (has_args ? "" : (", " + argument_list(arg_list)))
-                    + (has_xceptions ? "" : (", " + xception_list(x_list))) + ", GError **error)";
-
-    f_header_ << "gboolean " << class_name_lc << "_" << method_name << " " << params << ";" << endl;
-  }
-  f_header_ << endl;
-
-  // Generate the handler's implementation in the implementation file
-
-  // Generate the implementation boilerplate
-  f_service_ << "static void" << endl << class_name_lc << "_" << service_name_lc
-             << "_if_interface_init (" << this->nspace << service_name_ << "IfInterface *iface);"
-             << endl << endl;
-
-  args_indent = string(25, ' ');
-  f_service_ << "G_DEFINE_TYPE_WITH_CODE (" << class_name << ", " << endl << args_indent
-             << class_name_lc << "," << endl << args_indent << parent_type_name << "," << endl
-             << args_indent << "G_IMPLEMENT_INTERFACE (" << this->nspace_uc << "TYPE_"
-             << service_name_uc << "_IF," << endl;
-  args_indent += string(23, ' ');
-  f_service_ << args_indent << class_name_lc << "_" << service_name_lc << "_if_interface_init))"
-             << endl << endl;
-
-  // Generate the handler method implementations
-  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) {
-    string function_name = (*function_iter)->get_name();
-    string method_name = initial_caps_to_underscores(function_name);
-    t_type* return_type = (*function_iter)->get_returntype();
-    t_struct* arg_list = (*function_iter)->get_arglist();
-    t_struct* x_list = (*function_iter)->get_xceptions();
-
-    const vector<t_field*>& args = arg_list->get_members();
-    const vector<t_field*>& xceptions = x_list->get_members();
-
-    vector<t_field*>::const_iterator field_iter;
-
-    t_function implementing_function(return_type,
-                                     service_name_lc + "_handler_" + method_name,
-                                     arg_list,
-                                     x_list,
-                                     (*function_iter)->is_oneway());
-
-    indent(f_service_) << function_signature(&implementing_function) << endl;
-    scope_up(f_service_);
-    f_service_ << indent() << "g_return_val_if_fail (" << this->nspace_uc << "IS_"
-               << service_name_uc << "_HANDLER (iface), FALSE);" << endl << endl << indent()
-               << "return " << class_name_uc << "_GET_CLASS (iface)"
-               << "->" << method_name << " (iface, ";
-
-    if (!return_type->is_void()) {
-      f_service_ << "_return, ";
-    }
-    for (field_iter = args.begin(); field_iter != args.end(); ++field_iter) {
-      f_service_ << (*field_iter)->get_name() << ", ";
-    }
-    for (field_iter = xceptions.begin(); field_iter != xceptions.end(); ++field_iter) {
-      f_service_ << (*field_iter)->get_name() << ", ";
-    }
-    f_service_ << "error);" << endl;
-    scope_down(f_service_);
-    f_service_ << endl;
-  }
-
-  // Generate the handler interface initializer
-  f_service_ << "static void" << endl << class_name_lc << "_" << service_name_lc
-             << "_if_interface_init (" << this->nspace << service_name_ << "IfInterface *iface)"
-             << endl;
-  scope_up(f_service_);
-  if (functions.size() > 0) {
-    for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) {
-      string method_name = initial_caps_to_underscores((*function_iter)->get_name());
-
-      f_service_ << indent() << "iface->" << method_name << " = " << class_name_lc << "_"
-                 << method_name << ";" << endl;
-    }
-  }
-  else {
-    f_service_ << "THRIFT_UNUSED_VAR (iface);" << endl;
-  }
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate the handler instance initializer
-  f_service_ << "static void" << endl << class_name_lc << "_init (" << class_name << " *self)"
-             << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "THRIFT_UNUSED_VAR (self);" << endl;
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate the handler class initializer
-  f_service_ << "static void" << endl
-             << class_name_lc << "_class_init (" << class_name << "Class *cls)"
-             << endl;
-  scope_up(f_service_);
-  if (functions.size() > 0) {
-    for (function_iter = functions.begin();
-         function_iter != functions.end();
-         ++function_iter) {
-      string function_name = (*function_iter)->get_name();
-      string method_name = initial_caps_to_underscores(function_name);
-
-      // All methods are pure virtual and must be implemented by subclasses
-      f_service_ << indent() << "cls->" << method_name << " = NULL;" << endl;
-    }
-  }
-  else {
-    f_service_ << indent() << "THRIFT_UNUSED_VAR (cls);" << endl;
-  }
-  scope_down(f_service_);
-  f_service_ << endl;
-}
-
-/**
- * Generates C code that represents a Thrift service processor.
- *
- * @param tservice The service for which to generate a processor
- */
-void t_c_glib_generator::generate_service_processor(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator function_iter;
-
-  string service_name_lc = to_lower_case(initial_caps_to_underscores(service_name_));
-  string service_name_uc = to_upper_case(service_name_lc);
-
-  string class_name = this->nspace + service_name_ + "Processor";
-  string class_name_lc = to_lower_case(initial_caps_to_underscores(class_name));
-  string class_name_uc = to_upper_case(class_name_lc);
-
-  string parent_class_name;
-  string parent_type_name;
-
-  string handler_class_name = this->nspace + service_name_ + "Handler";
-  string handler_class_name_lc = initial_caps_to_underscores(handler_class_name);
-
-  string process_function_type_name = class_name + "ProcessFunction";
-  string process_function_def_type_name =
-    class_name_lc + "_process_function_def";
-
-  string function_name;
-  string args_indent;
-
-  // The service this service extends, or NULL if it extends no service
-  t_service* extends_service = tservice->get_extends();
-
-  // Determine the name of our parent service (if any) and the
-  // processor class' parent class name and type
-  if (extends_service) {
-    string parent_service_name = extends_service->get_name();
-    string parent_service_name_lc = to_lower_case(initial_caps_to_underscores(parent_service_name));
-    string parent_service_name_uc = to_upper_case(parent_service_name_lc);
-
-    parent_class_name = this->nspace + parent_service_name + "Processor";
-    parent_type_name = this->nspace_uc + "TYPE_" + parent_service_name_uc + "_PROCESSOR";
-  } else {
-    parent_class_name = "ThriftDispatchProcessor";
-    parent_type_name = "THRIFT_TYPE_DISPATCH_PROCESSOR";
-  }
-
-  // Generate the processor class' definition in the header file
-
-  // Generate the processor instance definition
-  f_header_ << "/* " << service_name_ << " processor */" << endl << "struct _" << class_name << endl
-            << "{" << endl;
-  indent_up();
-  f_header_ << indent() << parent_class_name << " parent;" << endl << endl << indent()
-            << "/* protected */" << endl << indent()
-            << this->nspace + service_name_ + "Handler *handler;" << endl << indent()
-            << "GHashTable *process_map;" << endl;
-  indent_down();
-  f_header_ << "};" << endl << "typedef struct _" << class_name << " " << class_name << ";" << endl
-            << endl;
-
-  // Generate the processor class definition
-  f_header_ << "struct _" << class_name << "Class" << endl << "{" << endl;
-  indent_up();
-  f_header_ << indent() << parent_class_name << "Class parent;" << endl << endl << indent()
-            << "/* protected */" << endl << indent()
-            << "gboolean (*dispatch_call) (ThriftDispatchProcessor *processor," << endl;
-  args_indent = indent() + string(27, ' ');
-  f_header_ << args_indent << "ThriftProtocol *in," << endl << args_indent << "ThriftProtocol *out,"
-            << endl << args_indent << "gchar *fname," << endl << args_indent << "gint32 seqid,"
-            << endl << args_indent << "GError **error);" << endl;
-  indent_down();
-  f_header_ << "};" << endl << "typedef struct _" << class_name << "Class " << class_name
-            << "Class;" << endl << endl;
-
-  // Generate the remaining header boilerplate
-  f_header_ << "GType " << class_name_lc << "_get_type (void);" << endl << "#define "
-            << this->nspace_uc << "TYPE_" << service_name_uc << "_PROCESSOR "
-            << "(" << class_name_lc << "_get_type())" << endl << "#define " << class_name_uc
-            << "(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_PROCESSOR, " << class_name << "))" << endl << "#define "
-            << this->nspace_uc << "IS_" << service_name_uc << "_PROCESSOR(obj) "
-            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_PROCESSOR))" << endl << "#define " << class_name_uc
-            << "_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_PROCESSOR, " << class_name << "Class))" << endl << "#define "
-            << this->nspace_uc << "IS_" << service_name_uc << "_PROCESSOR_CLASS(c) "
-            << "(G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc << "TYPE_" << service_name_uc
-            << "_PROCESSOR))" << endl << "#define " << this->nspace_uc << service_name_uc
-            << "_PROCESSOR_GET_CLASS(obj) "
-            << "(G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_"
-            << service_name_uc << "_PROCESSOR, " << class_name << "Class))" << endl << endl;
-
-  // Generate the processor's implementation in the implementation file
-
-  // Generate the processor's properties enum
-  f_service_ << "enum _" << class_name << "Properties" << endl << "{" << endl;
-  indent_up();
-  f_service_ << indent() << "PROP_" << class_name_uc << "_0," << endl << indent() << "PROP_"
-             << class_name_uc << "_HANDLER" << endl;
-  indent_down();
-  f_service_ << "};" << endl << endl;
-
-  // Generate the implementation boilerplate
-  args_indent = string(15, ' ');
-  f_service_ << "G_DEFINE_TYPE (" << class_name << "," << endl << args_indent << class_name_lc
-             << "," << endl << args_indent << parent_type_name << ")" << endl << endl;
-
-  // Generate the processor's processing-function type
-  args_indent = string(process_function_type_name.length() + 23, ' ');
-  f_service_ << "typedef gboolean (* " << process_function_type_name << ") ("
-             << class_name << " *, " << endl
-             << args_indent << "gint32," << endl
-             << args_indent << "ThriftProtocol *," << endl
-             << args_indent << "ThriftProtocol *," << endl
-             << args_indent << "GError **);" << endl
-             << endl;
-
-  // Generate the processor's processing-function-definition type
-  f_service_ << "typedef struct" << endl
-             << "{" << endl;
-  indent_up();
-  f_service_ << indent() << "gchar *name;" << endl
-             << indent() << process_function_type_name << " function;" << endl;
-  indent_down();
-  f_service_ << "} " << process_function_def_type_name << ";" << endl
-             << endl;
-
-  // Generate forward declarations of the processor's processing functions so we
-  // can refer to them in the processing-function-definition struct below and
-  // keep all of the processor's declarations in one place
-  for (function_iter = functions.begin();
-       function_iter != functions.end();
-       ++function_iter) {
-    function_name = class_name_lc + "_process_"
-      + initial_caps_to_underscores((*function_iter)->get_name());
-
-    args_indent = string(function_name.length() + 2, ' ');
-    f_service_ << "static gboolean" << endl
-               << function_name << " ("
-               << class_name << " *," << endl
-               << args_indent << "gint32," << endl
-               << args_indent << "ThriftProtocol *," << endl
-               << args_indent << "ThriftProtocol *," << endl
-               << args_indent << "GError **);" << endl;
-  }
-  f_service_ << endl;
-
-  // Generate the processor's processing-function definitions, if the service
-  // defines any methods
-  if (functions.size() > 0) {
-    f_service_ << indent() << "static " << process_function_def_type_name
-               << endl
-               << indent() << class_name_lc << "_process_function_defs["
-               << functions.size() << "] = {" << endl;
-    indent_up();
-    for (function_iter = functions.begin();
-         function_iter != functions.end();
-         ++function_iter) {
-      string service_function_name = (*function_iter)->get_name();
-      string process_function_name = class_name_lc + "_process_"
-        + initial_caps_to_underscores(service_function_name);
-
-      f_service_ << indent() << "{" << endl;
-      indent_up();
-      f_service_ << indent() << "\"" << service_function_name << "\"," << endl
-                 << indent() << process_function_name << endl;
-      indent_down();
-      f_service_ << indent() << "}"
-                 << (function_iter == --functions.end() ? "" : ",") << endl;
-    }
-    indent_down();
-    f_service_ << indent() << "};" << endl
-               << endl;
-  }
-
-  // Generate the processor's processing functions
-  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) {
-    string service_function_name = (*function_iter)->get_name();
-    string service_function_name_ic = underscores_to_initial_caps(service_function_name);
-    string service_function_name_lc = initial_caps_to_underscores(service_function_name);
-    string service_function_name_uc = to_upper_case(service_function_name_lc);
-
-    t_type* return_type = (*function_iter)->get_returntype();
-    bool has_return_value = !return_type->is_void();
-
-    t_struct* arg_list = (*function_iter)->get_arglist();
-    const vector<t_field*>& args = arg_list->get_members();
-    vector<t_field*>::const_iterator arg_iter;
-
-    const vector<t_field*>& xceptions = (*function_iter)->get_xceptions()->get_members();
-    vector<t_field*>::const_iterator xception_iter;
-
-    string args_class_name = this->nspace + service_name_ + service_function_name_ic + "Args";
-    string args_class_type = this->nspace_uc + "TYPE_" + service_name_uc + "_"
-                             + service_function_name_uc + "_ARGS";
-
-    string result_class_name = this->nspace + service_name_ + service_function_name_ic + "Result";
-    string result_class_type = this->nspace_uc + "TYPE_" + service_name_uc + "_"
-                               + service_function_name_uc + "_RESULT";
-
-    string handler_function_name = handler_class_name_lc + "_" + service_function_name_lc;
-
-    function_name = class_name_lc + "_process_"
-                    + initial_caps_to_underscores(service_function_name);
-
-    args_indent = string(function_name.length() + 2, ' ');
-    f_service_ << "static gboolean" << endl << function_name << " (" << class_name << " *self,"
-               << endl << args_indent << "gint32 sequence_id," << endl << args_indent
-               << "ThriftProtocol *input_protocol," << endl << args_indent
-               << "ThriftProtocol *output_protocol," << endl << args_indent << "GError **error)"
-               << endl;
-    scope_up(f_service_);
-    f_service_ << indent() << "gboolean result = TRUE;" << endl
-               << indent() << "ThriftTransport * transport;" << endl
-               << indent() << "ThriftApplicationException *xception;" << endl
-               << indent() << args_class_name + " * args =" << endl;
-    indent_up();
-    f_service_ << indent() << "g_object_new (" << args_class_type << ", NULL);" << endl << endl;
-    indent_down();
-    if ((*function_iter)->is_oneway()) {
-      f_service_ << indent() << "THRIFT_UNUSED_VAR (sequence_id);" << endl << indent()
-                 << "THRIFT_UNUSED_VAR (output_protocol);" << endl << endl;
-    }
-    f_service_ << indent() << "g_object_get (input_protocol, \"transport\", "
-               << "&transport, NULL);" << endl << endl;
-
-    // Read the method's arguments from the caller
-    f_service_ << indent() << "if ((thrift_struct_read (THRIFT_STRUCT (args), "
-               << "input_protocol, error) != -1) &&" << endl << indent()
-               << "    (thrift_protocol_read_message_end (input_protocol, "
-               << "error) != -1) &&" << endl << indent()
-               << "    (thrift_transport_read_end (transport, error) != FALSE))" << endl;
-    scope_up(f_service_);
-
-    for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) {
-      f_service_ << indent() << property_type_name((*arg_iter)->get_type()) << " "
-                 << (*arg_iter)->get_name() << ";" << endl;
-    }
-    for (xception_iter = xceptions.begin(); xception_iter != xceptions.end(); ++xception_iter) {
-      f_service_ << indent() << type_name((*xception_iter)->get_type()) << " "
-                 << initial_caps_to_underscores((*xception_iter)->get_name()) << " = NULL;" << endl;
-    }
-    if (has_return_value) {
-      f_service_ << indent() << property_type_name(return_type) << " return_value;" << endl;
-    }
-    if (!(*function_iter)->is_oneway()) {
-      f_service_ << indent() << result_class_name << " * result_struct;" << endl;
-    }
-    f_service_ << endl;
-
-    if (args.size() > 0) {
-      f_service_ << indent() << "g_object_get (args," << endl;
-      args_indent = indent() + string(14, ' ');
-      for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) {
-        string arg_name = (*arg_iter)->get_name();
-
-        f_service_ << args_indent << "\"" << arg_name << "\", &" << arg_name << "," << endl;
-      }
-      f_service_ << args_indent << "NULL);" << endl << endl;
-    }
-
-    if (!(*function_iter)->is_oneway()) {
-      f_service_ << indent() << "g_object_unref (transport);" << endl << indent()
-                 << "g_object_get (output_protocol, \"transport\", "
-                 << "&transport, NULL);" << endl << endl << indent()
-                 << "result_struct = g_object_new (" << result_class_type << ", NULL);" << endl;
-      if (has_return_value) {
-        f_service_ << indent() << "g_object_get (result_struct, "
-                                  "\"success\", &return_value, NULL);" << endl;
-      }
-      f_service_ << endl;
-    }
-
-    // Pass the arguments to the corresponding method in the handler
-    f_service_ << indent() << "if (" << handler_function_name << " (" << this->nspace_uc
-               << service_name_uc << "_IF (self->handler)," << endl;
-    args_indent = indent() + string(handler_function_name.length() + 6, ' ');
-    if (has_return_value) {
-      string return_type_name = type_name(return_type);
-
-      f_service_ << args_indent;
-
-      // Cast return_value if it was declared as a type other than the return
-      // value's actual type---this is true for integer values 32 bits or fewer
-      // in width, for which GLib requires a plain gint type be used when
-      // storing or retrieving as an object property
-      if (return_type_name != property_type_name(return_type)) {
-        if (return_type_name[return_type_name.length() - 1] != '*') {
-          return_type_name += ' ';
-        }
-        return_type_name += '*';
-
-        f_service_ << "(" << return_type_name << ")";
-      }
-
-      f_service_ << "&return_value," << endl;
-    }
-    for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) {
-      f_service_ << args_indent << (*arg_iter)->get_name() << "," << endl;
-    }
-    for (xception_iter = xceptions.begin(); xception_iter != xceptions.end(); ++xception_iter) {
-      f_service_ << args_indent << "&" << initial_caps_to_underscores((*xception_iter)->get_name())
-                 << "," << endl;
-    }
-    f_service_ << args_indent << "error) == TRUE)" << endl;
-    scope_up(f_service_);
-
-    // The handler reported success; return the result, if any, to the caller
-    if (!(*function_iter)->is_oneway()) {
-      if (has_return_value) {
-        f_service_ << indent() << "g_object_set (result_struct, \"success\", ";
-        if (type_name(return_type) != property_type_name(return_type)) {
-          // Roundtrip cast to fix the position of sign bit.
-          f_service_ << "(" << property_type_name(return_type) << ")"
-                     << "(" << type_name(return_type) << ")";
-        }
-        f_service_ << "return_value, "
-                   << "NULL);" << endl;
-
-        // Deallocate (or unref) return_value
-        return_type = get_true_type(return_type);
-        if (return_type->is_base_type()) {
-          t_base_type* base_type = ((t_base_type*)return_type);
-
-          if (base_type->get_base() == t_base_type::TYPE_STRING) {
-            f_service_ << indent() << "if (return_value != NULL)" << endl;
-            indent_up();
-            if (base_type->is_binary()) {
-              f_service_ << indent() << "g_byte_array_unref (return_value);" << endl;
-            } else {
-              f_service_ << indent() << "g_free (return_value);" << endl;
-            }
-            indent_down();
-          }
-        } else if (return_type->is_container()) {
-          f_service_ << indent() << "if (return_value != NULL)" << endl;
-          indent_up();
-
-          if (return_type->is_list()) {
-            t_type* elem_type = ((t_list*)return_type)->get_elem_type();
-
-            f_service_ << indent();
-            if (is_numeric(elem_type)) {
-              f_service_ << "g_array_unref";
-            } else {
-              f_service_ << "g_ptr_array_unref";
-            }
-            f_service_ << " (return_value);" << endl;
-          } else if (return_type->is_map() || return_type->is_set()) {
-            f_service_ << indent() << "g_hash_table_unref (return_value);" << endl;
-          }
-
-          indent_down();
-        } else if (return_type->is_struct()) {
-          f_service_ << indent() << "if (return_value != NULL)" << endl;
-          indent_up();
-          f_service_ << indent() << "g_object_unref (return_value);" << endl;
-          indent_down();
-        }
-
-        f_service_ << endl;
-      }
-      f_service_ << indent() << "result =" << endl;
-      indent_up();
-      f_service_ << indent() << "((thrift_protocol_write_message_begin (output_protocol," << endl;
-      args_indent = indent() + string(39, ' ');
-      f_service_ << args_indent << "\"" << service_function_name << "\"," << endl << args_indent
-                 << "T_REPLY," << endl << args_indent << "sequence_id," << endl << args_indent
-                 << "error) != -1) &&" << endl << indent()
-                 << " (thrift_struct_write (THRIFT_STRUCT (result_struct)," << endl;
-      args_indent = indent() + string(23, ' ');
-      f_service_ << args_indent << "output_protocol," << endl << args_indent << "error) != -1));"
-                 << endl;
-      indent_down();
-    }
-    scope_down(f_service_);
-    f_service_ << indent() << "else" << endl;
-    scope_up(f_service_);
-
-    // The handler reported failure; check to see if an application-defined
-    // exception was raised and if so, return it to the caller
-    f_service_ << indent();
-    if (xceptions.size() > 0) {
-      for (xception_iter = xceptions.begin(); xception_iter != xceptions.end(); ++xception_iter) {
-        f_service_ << "if (" << initial_caps_to_underscores((*xception_iter)->get_name())
-                   << " != NULL)" << endl;
-        scope_up(f_service_);
-        f_service_ << indent() << "g_object_set (result_struct," << endl;
-        args_indent = indent() + string(14, ' ');
-        f_service_ << args_indent << "\"" << (*xception_iter)->get_name() << "\", "
-                   << (*xception_iter)->get_name() << "," << endl << args_indent << "NULL);" << endl
-                   << endl;
-        f_service_ << indent() << "result =" << endl;
-        indent_up();
-        f_service_ << indent() << "((thrift_protocol_write_message_begin (output_protocol," << endl;
-        args_indent = indent() + string(39, ' ');
-        f_service_ << args_indent << "\"" << service_function_name << "\"," << endl << args_indent
-                   << "T_REPLY," << endl << args_indent << "sequence_id," << endl << args_indent
-                   << "error) != -1) &&" << endl << indent()
-                   << " (thrift_struct_write (THRIFT_STRUCT (result_struct)," << endl;
-        args_indent = indent() + string(23, ' ');
-        f_service_ << args_indent << "output_protocol," << endl << args_indent << "error) != -1));"
-                   << endl;
-        indent_down();
-        scope_down(f_service_);
-        f_service_ << indent() << "else" << endl;
-      }
-
-      scope_up(f_service_);
-      f_service_ << indent();
-    }
-
-    // If the handler reported failure but raised no application-defined
-    // exception, return a Thrift application exception with the information
-    // returned via GLib's own error-reporting mechanism
-    f_service_ << "if (*error == NULL)" << endl;
-    indent_up();
-    f_service_ << indent() << "g_warning (\"" << service_name_ << "."
-               << (*function_iter)->get_name() << " implementation returned FALSE \"" << endl
-               << indent() << string(11, ' ') << "\"but did not set an error\");" << endl << endl;
-    indent_down();
-    f_service_ << indent() << "xception =" << endl;
-    indent_up();
-    f_service_ << indent() << "g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION," << endl;
-    args_indent = indent() + string(14, ' ');
-    f_service_ << args_indent << "\"type\",    *error != NULL ? (*error)->code :" << endl
-               << args_indent << string(11, ' ') << "THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN,"
-               << endl << args_indent << "\"message\", *error != NULL ? (*error)->message : NULL,"
-               << endl << args_indent << "NULL);" << endl;
-    indent_down();
-    f_service_ << indent() << "g_clear_error (error);" << endl << endl << indent()
-               << "result =" << endl;
-    indent_up();
-    f_service_ << indent() << "((thrift_protocol_write_message_begin (output_protocol," << endl;
-    args_indent = indent() + string(39, ' ');
-    f_service_ << args_indent << "\"" << service_function_name << "\"," << endl << args_indent
-               << "T_EXCEPTION," << endl << args_indent << "sequence_id," << endl << args_indent
-               << "error) != -1) &&" << endl << indent()
-               << " (thrift_struct_write (THRIFT_STRUCT (xception)," << endl;
-    args_indent = indent() + string(23, ' ');
-    f_service_ << args_indent << "output_protocol," << endl << args_indent << "error) != -1));"
-               << endl;
-    indent_down();
-    f_service_ << endl << indent() << "g_object_unref (xception);" << endl;
-
-    if (xceptions.size() > 0) {
-      scope_down(f_service_);
-    }
-    scope_down(f_service_);
-    f_service_ << endl;
-
-    // Dellocate or unref retrieved argument values as necessary
-    for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) {
-      string arg_name = (*arg_iter)->get_name();
-      t_type* arg_type = get_true_type((*arg_iter)->get_type());
-
-      if (arg_type->is_base_type()) {
-        t_base_type* base_type = ((t_base_type*)arg_type);
-
-        if (base_type->get_base() == t_base_type::TYPE_STRING) {
-          f_service_ << indent() << "if (" << arg_name << " != NULL)" << endl;
-          indent_up();
-          if (base_type->is_binary()) {
-            f_service_ << indent() << "g_byte_array_unref (" << arg_name << ");" << endl;
-          } else {
-            f_service_ << indent() << "g_free (" << arg_name << ");" << endl;
-          }
-          indent_down();
-        }
-      } else if (arg_type->is_container()) {
-        f_service_ << indent() << "if (" << arg_name << " != NULL)" << endl;
-        indent_up();
-
-        if (arg_type->is_list()) {
-          t_type* elem_type = ((t_list*)arg_type)->get_elem_type();
-
-          f_service_ << indent();
-          if (is_numeric(elem_type)) {
-            f_service_ << "g_array_unref";
-          } else {
-            f_service_ << "g_ptr_array_unref";
-          }
-          f_service_ << " (" << arg_name << ");" << endl;
-        } else if (arg_type->is_map() || arg_type->is_set()) {
-          f_service_ << indent() << "g_hash_table_unref (" << arg_name << ");" << endl;
-        }
-
-        indent_down();
-      } else if (arg_type->is_struct()) {
-        f_service_ << indent() << "if (" << arg_name << " != NULL)" << endl;
-        indent_up();
-        f_service_ << indent() << "g_object_unref (" << arg_name << ");" << endl;
-        indent_down();
-      }
-    }
-
-    if (!(*function_iter)->is_oneway()) {
-      f_service_ << indent() << "g_object_unref (result_struct);" << endl << endl << indent()
-                 << "if (result == TRUE)" << endl;
-      indent_up();
-      f_service_ << indent() << "result =" << endl;
-      indent_up();
-      f_service_ << indent() << "((thrift_protocol_write_message_end "
-                 << "(output_protocol, error) != -1) &&" << endl << indent()
-                 << " (thrift_transport_write_end (transport, error) "
-                 << "!= FALSE) &&" << endl << indent()
-                 << " (thrift_transport_flush (transport, error) "
-                 << "!= FALSE));" << endl;
-      indent_down();
-      indent_down();
-    }
-    scope_down(f_service_);
-    f_service_ << indent() << "else" << endl;
-    indent_up();
-    f_service_ << indent() << "result = FALSE;" << endl;
-    indent_down();
-
-    f_service_ << endl << indent() << "g_object_unref (transport);" << endl << indent()
-               << "g_object_unref (args);" << endl << endl << indent() << "return result;" << endl;
-    scope_down(f_service_);
-
-    f_service_ << endl;
-  }
-
-  // Generate the processor's dispatch_call implementation
-  function_name = class_name_lc + "_dispatch_call";
-  args_indent = indent() + string(function_name.length() + 2, ' ');
-  f_service_ << "static gboolean" << endl << function_name
-             << " (ThriftDispatchProcessor *dispatch_processor," << endl << args_indent
-             << "ThriftProtocol *input_protocol," << endl << args_indent
-             << "ThriftProtocol *output_protocol," << endl << args_indent << "gchar *method_name,"
-             << endl << args_indent << "gint32 sequence_id," << endl << args_indent
-             << "GError **error)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << class_name_lc << "_process_function_def *"
-             << "process_function_def;" << endl;
-  f_service_ << indent() << "gboolean dispatch_result = FALSE;" << endl << endl << indent()
-             << class_name << " *self = " << class_name_uc << " (dispatch_processor);" << endl;
-  f_service_ << indent() << parent_class_name << "Class "
-                                                 "*parent_class =" << endl;
-  indent_up();
-  f_service_ << indent() << "g_type_class_peek_parent (" << class_name_uc << "_GET_CLASS (self));"
-             << endl;
-  indent_down();
-  f_service_ << endl
-             << indent() << "process_function_def = "
-             << "g_hash_table_lookup (self->process_map, method_name);" << endl
-             << indent() << "if (process_function_def != NULL)" << endl;
-  scope_up(f_service_);
-  args_indent = indent() + string(53, ' ');
-  f_service_ << indent() << "g_free (method_name);" << endl
-             << indent() << "dispatch_result = "
-             << "(*process_function_def->function) (self," << endl
-             << args_indent << "sequence_id," << endl
-             << args_indent << "input_protocol," << endl
-             << args_indent << "output_protocol," << endl
-             << args_indent << "error);" << endl;
-  scope_down(f_service_);
-  f_service_ << indent() << "else" << endl;
-  scope_up(f_service_);
-
-  // Method name not recognized; chain up to our parent processor---note the
-  // top-most implementation of this method, in ThriftDispatchProcessor itself,
-  // will return an application exception to the caller if no class in the
-  // hierarchy recognizes the method name
-  f_service_ << indent() << "dispatch_result = parent_class->dispatch_call "
-                            "(dispatch_processor," << endl;
-  args_indent = indent() + string(47, ' ');
-  f_service_ << args_indent << "input_protocol," << endl << args_indent << "output_protocol,"
-             << endl << args_indent << "method_name," << endl << args_indent << "sequence_id,"
-             << endl << args_indent << "error);" << endl;
-  scope_down(f_service_);
-  f_service_ << endl << indent() << "return dispatch_result;" << endl;
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate the processor's property setter
-  function_name = class_name_lc + "_set_property";
-  args_indent = string(function_name.length() + 2, ' ');
-  f_service_ << "static void" << endl << function_name << " (GObject *object," << endl
-             << args_indent << "guint property_id," << endl << args_indent << "const GValue *value,"
-             << endl << args_indent << "GParamSpec *pspec)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl
-             << endl << indent() << "switch (property_id)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "case PROP_" << class_name_uc << "_HANDLER:" << endl;
-  indent_up();
-  f_service_ << indent() << "if (self->handler != NULL)" << endl;
-  indent_up();
-  f_service_ << indent() << "g_object_unref (self->handler);" << endl;
-  indent_down();
-  f_service_ << indent() << "self->handler = g_value_get_object (value);" << endl << indent()
-             << "g_object_ref (self->handler);" << endl;
-  if (extends_service) {
-    // Chain up to set the handler in every superclass as well
-    f_service_ << endl << indent() << "G_OBJECT_CLASS (" << class_name_lc << "_parent_class)->"
-               << endl;
-    indent_up();
-    f_service_ << indent() << "set_property (object, property_id, value, pspec);" << endl;
-    indent_down();
-  }
-  f_service_ << indent() << "break;" << endl;
-  indent_down();
-  f_service_ << indent() << "default:" << endl;
-  indent_up();
-  f_service_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);"
-             << endl << indent() << "break;" << endl;
-  indent_down();
-  scope_down(f_service_);
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate processor's property getter
-  function_name = class_name_lc + "_get_property";
-  args_indent = string(function_name.length() + 2, ' ');
-  f_service_ << "static void" << endl << function_name << " (GObject *object," << endl
-             << args_indent << "guint property_id," << endl << args_indent << "GValue *value,"
-             << endl << args_indent << "GParamSpec *pspec)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl
-             << endl << indent() << "switch (property_id)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "case PROP_" << class_name_uc << "_HANDLER:" << endl;
-  indent_up();
-  f_service_ << indent() << "g_value_set_object (value, self->handler);" << endl << indent()
-             << "break;" << endl;
-  indent_down();
-  f_service_ << indent() << "default:" << endl;
-  indent_up();
-  f_service_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);"
-             << endl << indent() << "break;" << endl;
-  indent_down();
-  scope_down(f_service_);
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generator the processor's dispose function
-  f_service_ << "static void" << endl << class_name_lc << "_dispose (GObject *gobject)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << class_name << " *self = " << class_name_uc << " (gobject);" << endl
-             << endl << indent() << "if (self->handler != NULL)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "g_object_unref (self->handler);" << endl << indent()
-             << "self->handler = NULL;" << endl;
-  scope_down(f_service_);
-  f_service_ << endl << indent() << "G_OBJECT_CLASS (" << class_name_lc << "_parent_class)"
-                                                                           "->dispose (gobject);"
-             << endl;
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate processor finalize function
-  f_service_ << "static void" << endl << class_name_lc << "_finalize (GObject *gobject)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << this->nspace << service_name_ << "Processor *self = " << this->nspace_uc
-             << service_name_uc << "_PROCESSOR (gobject);" << endl << endl << indent()
-             << "thrift_safe_hash_table_destroy (self->process_map);" << endl << endl << indent()
-             << "G_OBJECT_CLASS (" << class_name_lc << "_parent_class)"
-                                                       "->finalize (gobject);" << endl;
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate processor instance initializer
-  f_service_ << "static void" << endl << class_name_lc << "_init (" << class_name << " *self)"
-             << endl;
-  scope_up(f_service_);
-  if (functions.size() > 0) {
-    f_service_ << indent() << "guint index;" << endl
-               << endl;
-  }
-  f_service_ << indent() << "self->handler = NULL;" << endl << indent()
-             << "self->process_map = "
-                "g_hash_table_new (g_str_hash, g_str_equal);" << endl;
-  if (functions.size() > 0) {
-    args_indent = string(21, ' ');
-    f_service_ << endl
-               << indent() << "for (index = 0; index < "
-               << functions.size() << "; index += 1)" << endl;
-    indent_up();
-    f_service_ << indent() << "g_hash_table_insert (self->process_map," << endl
-               << indent() << args_indent
-               << class_name_lc << "_process_function_defs[index].name," << endl
-               << indent() << args_indent
-               << "&" << class_name_lc << "_process_function_defs[index]" << ");"
-               << endl;
-    indent_down();
-  }
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  // Generate processor class initializer
-  f_service_ << "static void" << endl << class_name_lc << "_class_init (" << class_name
-             << "Class *cls)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "GObjectClass *gobject_class = G_OBJECT_CLASS (cls);" << endl
-             << indent() << "ThriftDispatchProcessorClass *dispatch_processor_class =" << endl;
-  indent_up();
-  f_service_ << indent() << "THRIFT_DISPATCH_PROCESSOR_CLASS (cls);" << endl;
-  indent_down();
-  f_service_ << indent() << "GParamSpec *param_spec;" << endl << endl << indent()
-             << "gobject_class->dispose = " << class_name_lc << "_dispose;" << endl << indent()
-             << "gobject_class->finalize = " << class_name_lc << "_finalize;" << endl << indent()
-             << "gobject_class->set_property = " << class_name_lc << "_set_property;" << endl
-             << indent() << "gobject_class->get_property = " << class_name_lc << "_get_property;"
-             << endl << endl << indent()
-             << "dispatch_processor_class->dispatch_call = " << class_name_lc << "_dispatch_call;"
-             << endl << indent() << "cls->dispatch_call = " << class_name_lc << "_dispatch_call;"
-             << endl << endl << indent() << "param_spec = g_param_spec_object (\"handler\","
-             << endl;
-  args_indent = indent() + string(34, ' ');
-  f_service_ << args_indent << "\"Service handler implementation\"," << endl << args_indent
-             << "\"The service handler implementation \"" << endl << args_indent
-             << "\"to which method calls are dispatched.\"," << endl << args_indent
-             << this->nspace_uc + "TYPE_" + service_name_uc + "_HANDLER," << endl << args_indent
-             << "G_PARAM_READWRITE);" << endl;
-  f_service_ << indent() << "g_object_class_install_property (gobject_class," << endl;
-  args_indent = indent() + string(33, ' ');
-  f_service_ << args_indent << "PROP_" << class_name_uc << "_HANDLER," << endl << args_indent
-             << "param_spec);" << endl;
-  scope_down(f_service_);
-}
-
-/**
- * Generates C code that represents a Thrift service server.
- */
-void t_c_glib_generator::generate_service_server(t_service* tservice) {
-  (void)tservice;
-  // Generate the service's handler class
-  generate_service_handler(tservice);
-
-  // Generate the service's processor class
-  generate_service_processor(tservice);
-}
-
-/**
- * Generates C code to represent a THrift structure as a GObject.
- */
-void t_c_glib_generator::generate_object(t_struct* tstruct) {
-  string name = tstruct->get_name();
-  string name_u = initial_caps_to_underscores(name);
-  string name_uc = to_upper_case(name_u);
-
-  string class_name = this->nspace + name;
-  string class_name_lc = to_lower_case(initial_caps_to_underscores(class_name));
-  string class_name_uc = to_upper_case(class_name_lc);
-
-  string function_name;
-  string args_indent;
-
-  // write the instance definition
-  f_types_ << "struct _" << this->nspace << name << endl << "{ " << endl
-           << "  ThriftStruct parent; " << endl << endl << "  /* public */" << endl;
-
-  // for each field, add a member variable
-  vector<t_field*>::const_iterator m_iter;
-  const vector<t_field*>& members = tstruct->get_members();
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = get_true_type((*m_iter)->get_type());
-    f_types_ << "  " << type_name(t) << " " << (*m_iter)->get_name() << ";" << endl;
-    if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
-      f_types_ << "  gboolean __isset_" << (*m_iter)->get_name() << ";" << endl;
-    }
-  }
-
-  // close the structure definition and create a typedef
-  f_types_ << "};" << endl << "typedef struct _" << this->nspace << name << " " << this->nspace
-           << name << ";" << endl << endl;
-
-  // write the class definition
-  f_types_ << "struct _" << this->nspace << name << "Class" << endl << "{" << endl
-           << "  ThriftStructClass parent;" << endl << "};" << endl << "typedef struct _"
-           << this->nspace << name << "Class " << this->nspace << name << "Class;" << endl << endl;
-
-  // write the standard GObject boilerplate
-  f_types_ << "GType " << this->nspace_lc << name_u << "_get_type (void);" << endl << "#define "
-           << this->nspace_uc << "TYPE_" << name_uc << " (" << this->nspace_lc << name_u
-           << "_get_type())" << endl << "#define " << this->nspace_uc << name_uc
-           << "(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_" << name_uc
-           << ", " << this->nspace << name << "))" << endl << "#define " << this->nspace_uc
-           << name_uc << "_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "_TYPE_"
-           << name_uc << ", " << this->nspace << name << "Class))" << endl << "#define "
-           << this->nspace_uc << "IS_" << name_uc << "(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), "
-           << this->nspace_uc << "TYPE_" << name_uc << "))" << endl << "#define " << this->nspace_uc
-           << "IS_" << name_uc << "_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc
-           << "TYPE_" << name_uc << "))" << endl << "#define " << this->nspace_uc << name_uc
-           << "_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_"
-           << name_uc << ", " << this->nspace << name << "Class))" << endl << endl;
-
-  // start writing the object implementation .c file
-
-  // generate properties enum
-  if (members.size() > 0) {
-    f_types_impl_ << "enum _" << class_name << "Properties" << endl << "{" << endl;
-    indent_up();
-    f_types_impl_ << indent() << "PROP_" << class_name_uc << "_0";
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      string member_name_uc
-          = to_upper_case(to_lower_case(initial_caps_to_underscores((*m_iter)->get_name())));
-
-      f_types_impl_ << "," << endl << indent() << "PROP_" << class_name_uc << "_" << member_name_uc;
-    }
-    f_types_impl_ << endl;
-    indent_down();
-    f_types_impl_ << "};" << endl << endl;
-  }
-
-  // generate struct I/O methods
-  string this_get = this->nspace + name + " * this_object = " + this->nspace_uc + name_uc
-                    + "(object);";
-  generate_struct_reader(f_types_impl_, tstruct, "this_object->", this_get);
-  generate_struct_writer(f_types_impl_, tstruct, "this_object->", this_get);
-
-  // generate property setter and getter
-  if (members.size() > 0) {
-    // generate property setter
-    function_name = class_name_lc + "_set_property";
-    args_indent = string(function_name.length() + 2, ' ');
-    f_types_impl_ << "static void" << endl << function_name << " (GObject *object," << endl
-                  << args_indent << "guint property_id," << endl << args_indent
-                  << "const GValue *value," << endl << args_indent << "GParamSpec *pspec)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl
-                  << endl << indent() << "switch (property_id)" << endl;
-    scope_up(f_types_impl_);
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      t_field* member = (*m_iter);
-      string member_name = member->get_name();
-      string member_name_uc
-          = to_upper_case(to_lower_case(initial_caps_to_underscores(member_name)));
-      t_type* member_type = get_true_type(member->get_type());
-
-      string property_identifier = "PROP_" + class_name_uc + "_" + member_name_uc;
-
-      f_types_impl_ << indent() << "case " << property_identifier + ":" << endl;
-      indent_up();
-
-      if (member_type->is_base_type()) {
-        t_base_type* base_type = ((t_base_type*)member_type);
-        string assign_function_name;
-
-        if (base_type->get_base() == t_base_type::TYPE_STRING) {
-          string release_function_name;
-
-          f_types_impl_ << indent() << "if (self->" << member_name << " != NULL)" << endl;
-          indent_up();
-
-          if (base_type->is_binary()) {
-            release_function_name = "g_byte_array_unref";
-            assign_function_name = "g_value_dup_boxed";
-          } else {
-            release_function_name = "g_free";
-            assign_function_name = "g_value_dup_string";
-          }
-
-          f_types_impl_ << indent() << release_function_name << " (self->" << member_name << ");"
-                        << endl;
-          indent_down();
-        } else {
-          switch (base_type->get_base()) {
-          case t_base_type::TYPE_BOOL:
-            assign_function_name = "g_value_get_boolean";
-            break;
-
-          case t_base_type::TYPE_I8:
-          case t_base_type::TYPE_I16:
-          case t_base_type::TYPE_I32:
-            assign_function_name = "g_value_get_int";
-            break;
-
-          case t_base_type::TYPE_I64:
-            assign_function_name = "g_value_get_int64";
-            break;
-
-          case t_base_type::TYPE_DOUBLE:
-            assign_function_name = "g_value_get_double";
-            break;
-
-          default:
-            throw "compiler error: "
-                  "unrecognized base type \"" + base_type->get_name() + "\" "
-                                                                        "for struct member \""
-                + member_name + "\"";
-            break;
-          }
-        }
-
-        f_types_impl_ << indent() << "self->" << member_name << " = " << assign_function_name
-                      << " (value);" << endl;
-      } else if (member_type->is_enum()) {
-        f_types_impl_ << indent() << "self->" << member_name << " = g_value_get_int (value);"
-                      << endl;
-      } else if (member_type->is_container()) {
-        string release_function_name;
-        string assign_function_name;
-
-        if (member_type->is_list()) {
-          t_type* elem_type = ((t_list*)member_type)->get_elem_type();
-
-          // Lists of base types other than strings are represented as GArrays;
-          // all others as GPtrArrays
-          if (is_numeric(elem_type)) {
-            release_function_name = "g_array_unref";
-          } else {
-            release_function_name = "g_ptr_array_unref";
-          }
-
-          assign_function_name = "g_value_dup_boxed";
-        } else if (member_type->is_set() || member_type->is_map()) {
-          release_function_name = "g_hash_table_unref";
-          assign_function_name = "g_value_dup_boxed";
-        }
-
-        f_types_impl_ << indent() << "if (self->" << member_name << " != NULL)" << endl;
-        indent_up();
-        f_types_impl_ << indent() << release_function_name << " (self->" << member_name << ");"
-                      << endl;
-        indent_down();
-        f_types_impl_ << indent() << "self->" << member_name << " = " << assign_function_name
-                      << " (value);" << endl;
-      } else if (member_type->is_struct() || member_type->is_xception()) {
-        f_types_impl_ << indent() << "if (self->" << member_name << " != NULL)" << endl;
-        indent_up();
-        f_types_impl_ << indent() << "g_object_unref (self->" << member_name << ");" << endl;
-        indent_down();
-        f_types_impl_ << indent() << "self->" << member_name << " = g_value_dup_object (value);"
-                      << endl;
-      }
-
-      if (member->get_req() != t_field::T_REQUIRED) {
-        f_types_impl_ << indent() << "self->__isset_" << member_name << " = TRUE;" << endl;
-      }
-
-      f_types_impl_ << indent() << "break;" << endl << endl;
-      indent_down();
-    }
-    f_types_impl_ << indent() << "default:" << endl;
-    indent_up();
-    f_types_impl_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);"
-                  << endl << indent() << "break;" << endl;
-    indent_down();
-    scope_down(f_types_impl_);
-    scope_down(f_types_impl_);
-    f_types_impl_ << endl;
-
-    // generate property getter
-    function_name = class_name_lc + "_get_property";
-    args_indent = string(function_name.length() + 2, ' ');
-    f_types_impl_ << "static void" << endl << function_name << " (GObject *object," << endl
-                  << args_indent << "guint property_id," << endl << args_indent << "GValue *value,"
-                  << endl << args_indent << "GParamSpec *pspec)" << endl;
-    scope_up(f_types_impl_);
-    f_types_impl_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl
-                  << endl << indent() << "switch (property_id)" << endl;
-    scope_up(f_types_impl_);
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      t_field* member = (*m_iter);
-      string member_name = (*m_iter)->get_name();
-      string member_name_uc
-          = to_upper_case(to_lower_case(initial_caps_to_underscores(member_name)));
-      t_type* member_type = get_true_type(member->get_type());
-
-      string property_identifier = "PROP_" + class_name_uc + "_" + member_name_uc;
-
-      string setter_function_name;
-
-      if (member_type->is_base_type()) {
-        t_base_type* base_type = ((t_base_type*)member_type);
-
-        switch (base_type->get_base()) {
-        case t_base_type::TYPE_BOOL:
-          setter_function_name = "g_value_set_boolean";
-          break;
-
-        case t_base_type::TYPE_I8:
-        case t_base_type::TYPE_I16:
-        case t_base_type::TYPE_I32:
-          setter_function_name = "g_value_set_int";
-          break;
-
-        case t_base_type::TYPE_I64:
-          setter_function_name = "g_value_set_int64";
-          break;
-
-        case t_base_type::TYPE_DOUBLE:
-          setter_function_name = "g_value_set_double";
-          break;
-
-        case t_base_type::TYPE_STRING:
-          if (base_type->is_binary()) {
-            setter_function_name = "g_value_set_boxed";
-          } else {
-            setter_function_name = "g_value_set_string";
-          }
-          break;
-
-        default:
-          throw "compiler error: "
-                "unrecognized base type \"" + base_type->get_name() + "\" "
-                                                                      "for struct member \""
-              + member_name + "\"";
-          break;
-        }
-      } else if (member_type->is_enum()) {
-        setter_function_name = "g_value_set_int";
-      } else if (member_type->is_struct() || member_type->is_xception()) {
-        setter_function_name = "g_value_set_object";
-      } else if (member_type->is_container()) {
-        setter_function_name = "g_value_set_boxed";
-      } else {
-        throw "compiler error: "
-              "unrecognized type for struct member \"" + member_name + "\"";
-      }
-
-      f_types_impl_ << indent() << "case " << property_identifier + ":" << endl;
-      indent_up();
-      f_types_impl_ << indent() << setter_function_name << " (value, self->" << member_name << ");"
-                    << endl << indent() << "break;" << endl << endl;
-      indent_down();
-    }
-    f_types_impl_ << indent() << "default:" << endl;
-    indent_up();
-    f_types_impl_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);"
-                  << endl << indent() << "break;" << endl;
-    indent_down();
-    scope_down(f_types_impl_);
-    scope_down(f_types_impl_);
-    f_types_impl_ << endl;
-  }
-
-  // generate the instance init function
-
-  f_types_impl_ << "static void " << endl << this->nspace_lc << name_u << "_instance_init ("
-                << this->nspace << name << " * object)" << endl << "{" << endl;
-  indent_up();
-
-  // generate default-value structures for container-type members
-  bool constant_declaration_output = false;
-  bool string_list_constant_output = false;
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_field* member = *m_iter;
-    t_const_value* member_value = member->get_value();
-
-    if (member_value != NULL) {
-      string member_name = member->get_name();
-      t_type* member_type = get_true_type(member->get_type());
-
-      if (member_type->is_list()) {
-        const vector<t_const_value*>& list = member_value->get_list();
-        t_type* elem_type = ((t_list*)member_type)->get_elem_type();
-
-        // Generate an array with the list literal
-        indent(f_types_impl_) << "static " << type_name(elem_type, false, true) << " __default_"
-                              << member_name << "[" << list.size() << "] = " << endl;
-        indent_up();
-        f_types_impl_ << indent() << constant_literal(member_type, member_value) << ";" << endl;
-        indent_down();
-
-        constant_declaration_output = true;
-
-        // If we are generating values for a pointer array (i.e. a list of
-        // strings), set a flag so we know to also declare an index variable to
-        // use in pre-populating the array
-        if (elem_type->is_string()) {
-          string_list_constant_output = true;
-        }
-      }
-
-      // TODO: Handle container types other than list
-    }
-  }
-  if (constant_declaration_output) {
-    if (string_list_constant_output) {
-      indent(f_types_impl_) << "unsigned int list_index;" << endl;
-    }
-
-    f_types_impl_ << endl;
-  }
-
-  // satisfy compilers with -Wall turned on
-  indent(f_types_impl_) << "/* satisfy -Wall */" << endl << indent()
-                        << "THRIFT_UNUSED_VAR (object);" << endl;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = get_true_type((*m_iter)->get_type());
-    if (t->is_base_type()) {
-      string dval = " = ";
-      if (t->is_enum()) {
-        dval += "(" + type_name(t) + ")";
-      }
-      t_const_value* cv = (*m_iter)->get_value();
-      if (cv != NULL) {
-        dval += constant_value("", t, cv);
-      } else {
-        dval += t->is_string() ? "NULL" : "0";
-      }
-      indent(f_types_impl_) << "object->" << (*m_iter)->get_name() << dval << ";" << endl;
-    } else if (t->is_struct()) {
-      string name = (*m_iter)->get_name();
-      string type_name_uc
-          = to_upper_case(initial_caps_to_underscores((*m_iter)->get_type()->get_name()));
-      indent(f_types_impl_) << "object->" << name << " = g_object_new (" << this->nspace_uc
-                            << "TYPE_" << type_name_uc << ", NULL);" << endl;
-    } else if (t->is_xception()) {
-      string name = (*m_iter)->get_name();
-      indent(f_types_impl_) << "object->" << name << " = NULL;" << endl;
-    } else if (t->is_container()) {
-      string name = (*m_iter)->get_name();
-      string init_function;
-      t_type* etype = NULL;
-
-      if (t->is_map()) {
-        t_type* key = ((t_map*)t)->get_key_type();
-        t_type* value = ((t_map*)t)->get_val_type();
-        init_function = generate_new_hash_from_type(key, value);
-      } else if (t->is_set()) {
-        etype = ((t_set*)t)->get_elem_type();
-        init_function = generate_new_hash_from_type(etype, NULL);
-      } else if (t->is_list()) {
-        etype = ((t_list*)t)->get_elem_type();
-        init_function = generate_new_array_from_type(etype);
-      }
-
-      indent(f_types_impl_) << "object->" << name << " = " << init_function << endl;
-
-      // Pre-populate the container with the specified default values, if any
-      if ((*m_iter)->get_value()) {
-        t_const_value* member_value = (*m_iter)->get_value();
-
-        if (t->is_list()) {
-          const vector<t_const_value*>& list = member_value->get_list();
-
-          if (is_numeric(etype)) {
-            indent(f_types_impl_) <<
-              "g_array_append_vals (object->" << name << ", &__default_" <<
-              name << ", " << list.size() << ");" << endl;
-          }
-          else {
-            indent(f_types_impl_) <<
-              "for (list_index = 0; list_index < " << list.size() << "; " <<
-              "list_index += 1)" << endl;
-            indent_up();
-            indent(f_types_impl_) <<
-              "g_ptr_array_add (object->" << name << "," << endl <<
-              indent() << string(17, ' ') << "g_strdup (__default_" <<
-              name << "[list_index]));" << endl;
-            indent_down();
-          }
-        }
-
-        // TODO: Handle container types other than list
-      }
-    }
-
-    /* if not required, initialize the __isset variable */
-    if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
-      indent(f_types_impl_) << "object->__isset_" << (*m_iter)->get_name() << " = FALSE;" << endl;
-    }
-  }
-
-  indent_down();
-  f_types_impl_ << "}" << endl << endl;
-
-  /* create the destructor */
-  f_types_impl_ << "static void " << endl << this->nspace_lc << name_u
-                << "_finalize (GObject *object)" << endl << "{" << endl;
-  indent_up();
-
-  f_types_impl_ << indent() << this->nspace << name << " *tobject = " << this->nspace_uc << name_uc
-                << " (object);" << endl << endl;
-
-  f_types_impl_ << indent() << "/* satisfy -Wall in case we don't use tobject */" << endl
-                << indent() << "THRIFT_UNUSED_VAR (tobject);" << endl;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = get_true_type((*m_iter)->get_type());
-    if (t->is_container()) {
-      string name = (*m_iter)->get_name();
-      if (t->is_map() || t->is_set()) {
-        f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl;
-        f_types_impl_ << indent() << "{" << endl;
-        indent_up();
-        f_types_impl_ << indent() << "g_hash_table_destroy (tobject->" << name << ");" << endl;
-        f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl;
-        indent_down();
-        f_types_impl_ << indent() << "}" << endl;
-      } else if (t->is_list()) {
-        t_type* etype = ((t_list*)t)->get_elem_type();
-        string destructor_function = "g_ptr_array_unref";
-
-        if (etype->is_base_type()) {
-          t_base_type::t_base tbase = ((t_base_type*)etype)->get_base();
-          switch (tbase) {
-          case t_base_type::TYPE_VOID:
-            throw "compiler error: cannot determine array type";
-          case t_base_type::TYPE_BOOL:
-          case t_base_type::TYPE_I8:
-          case t_base_type::TYPE_I16:
-          case t_base_type::TYPE_I32:
-          case t_base_type::TYPE_I64:
-          case t_base_type::TYPE_DOUBLE:
-            destructor_function = "g_array_unref";
-            break;
-          case t_base_type::TYPE_STRING:
-            break;
-          default:
-            throw "compiler error: no array info for type";
-          }
-        } else if (etype->is_enum()) {
-          destructor_function = "g_array_unref";
-        }
-
-        f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl;
-        f_types_impl_ << indent() << "{" << endl;
-        indent_up();
-        f_types_impl_ << indent() << destructor_function << " (tobject->" << name << ");" << endl;
-        f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl;
-        indent_down();
-        f_types_impl_ << indent() << "}" << endl;
-      }
-    } else if (t->is_struct() || t->is_xception()) {
-      string name = (*m_iter)->get_name();
-      // TODO: g_clear_object needs glib >= 2.28
-      // f_types_impl_ << indent() << "g_clear_object (&(tobject->" << name << "));" << endl;
-      // does g_object_unref the trick?
-      f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl;
-      f_types_impl_ << indent() << "{" << endl;
-      indent_up();
-      f_types_impl_ << indent() << "g_object_unref(tobject->" << name << ");" << endl;
-      f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl;
-      indent_down();
-      f_types_impl_ << indent() << "}" << endl;
-    } else if (t->is_string()) {
-      string name = (*m_iter)->get_name();
-      f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl;
-      f_types_impl_ << indent() << "{" << endl;
-      indent_up();
-      f_types_impl_ << indent() << generate_free_func_from_type(t) << "(tobject->" << name << ");"
-                    << endl;
-      f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl;
-      indent_down();
-      f_types_impl_ << indent() << "}" << endl;
-    }
-  }
-
-  indent_down();
-  f_types_impl_ << "}" << endl << endl;
-
-  // generate the class init function
-
-  f_types_impl_ << "static void" << endl << class_name_lc << "_class_init (" << class_name
-                << "Class * cls)" << endl;
-  scope_up(f_types_impl_);
-
-  f_types_impl_ << indent() << "GObjectClass *gobject_class = G_OBJECT_CLASS (cls);" << endl
-                << indent() << "ThriftStructClass *struct_class = "
-                << "THRIFT_STRUCT_CLASS (cls);" << endl << endl << indent()
-                << "struct_class->read = " << class_name_lc << "_read;" << endl << indent()
-                << "struct_class->write = " << class_name_lc << "_write;" << endl << endl
-                << indent() << "gobject_class->finalize = " << class_name_lc << "_finalize;"
-                << endl;
-  if (members.size() > 0) {
-    f_types_impl_ << indent() << "gobject_class->get_property = " << class_name_lc
-                  << "_get_property;" << endl << indent()
-                  << "gobject_class->set_property = " << class_name_lc << "_set_property;" << endl;
-
-    // install a property for each member
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      t_field* member = (*m_iter);
-      string member_name = member->get_name();
-      string member_name_uc
-          = to_upper_case(to_lower_case(initial_caps_to_underscores(member_name)));
-      t_type* member_type = get_true_type(member->get_type());
-      t_const_value* member_value = member->get_value();
-
-      string property_identifier = "PROP_" + class_name_uc + "_" + member_name_uc;
-
-      f_types_impl_ << endl << indent() << "g_object_class_install_property" << endl;
-      indent_up();
-      args_indent = indent() + ' ';
-      f_types_impl_ << indent() << "(gobject_class," << endl << args_indent << property_identifier
-                    << "," << endl << args_indent;
-
-      if (member_type->is_base_type()) {
-        t_base_type::t_base base_type = ((t_base_type*)member_type)->get_base();
-
-        if (base_type == t_base_type::TYPE_STRING) {
-          if (((t_base_type*)member_type)->is_binary()) {
-            args_indent += string(20, ' ');
-            f_types_impl_ << "g_param_spec_boxed (\"" << member_name << "\"," << endl << args_indent
-                          << "NULL," << endl << args_indent << "NULL," << endl << args_indent
-                          << "G_TYPE_BYTE_ARRAY," << endl << args_indent << "G_PARAM_READWRITE));"
-                          << endl;
-          } else {
-            args_indent += string(21, ' ');
-            f_types_impl_ << "g_param_spec_string (\"" << member_name << "\"," << endl
-                          << args_indent << "NULL," << endl << args_indent << "NULL," << endl
-                          << args_indent
-                          << ((member_value != NULL) ? "\"" + member_value->get_string() + "\""
-                                                     : "NULL") << "," << endl << args_indent
-                          << "G_PARAM_READWRITE));" << endl;
-          }
-        } else if (base_type == t_base_type::TYPE_BOOL) {
-          args_indent += string(22, ' ');
-          f_types_impl_ << "g_param_spec_boolean (\"" << member_name << "\"," << endl << args_indent
-                        << "NULL," << endl << args_indent << "NULL," << endl << args_indent
-                        << (((member_value != NULL) && (member_value->get_integer() != 0))
-                                ? "TRUE"
-                                : "FALSE") << "," << endl << args_indent << "G_PARAM_READWRITE));"
-                        << endl;
-        } else if ((base_type == t_base_type::TYPE_I8) || (base_type == t_base_type::TYPE_I16)
-                   || (base_type == t_base_type::TYPE_I32) || (base_type == t_base_type::TYPE_I64)
-                   || (base_type == t_base_type::TYPE_DOUBLE)) {
-          string param_spec_function_name = "g_param_spec_int";
-          string min_value;
-          string max_value;
-          ostringstream default_value;
-
-          switch (base_type) {
-          case t_base_type::TYPE_I8:
-            min_value = "G_MININT8";
-            max_value = "G_MAXINT8";
-            break;
-
-          case t_base_type::TYPE_I16:
-            min_value = "G_MININT16";
-            max_value = "G_MAXINT16";
-            break;
-
-          case t_base_type::TYPE_I32:
-            min_value = "G_MININT32";
-            max_value = "G_MAXINT32";
-            break;
-
-          case t_base_type::TYPE_I64:
-            param_spec_function_name = "g_param_spec_int64";
-            min_value = "G_MININT64";
-            max_value = "G_MAXINT64";
-            break;
-
-          case t_base_type::TYPE_DOUBLE:
-            param_spec_function_name = "g_param_spec_double";
-            min_value = "-INFINITY";
-            max_value = "INFINITY";
-            break;
-
-          default:
-            throw "compiler error: "
-                  "unrecognized base type \"" + member_type->get_name() + "\" "
-                                                                          "for struct member \""
-                + member_name + "\"";
-            break;
-          }
-
-          if (member_value != NULL) {
-            default_value << (base_type == t_base_type::TYPE_DOUBLE ? member_value->get_double()
-                                                                    : member_value->get_integer());
-          } else {
-            default_value << "0";
-          }
-
-          args_indent += string(param_spec_function_name.length() + 2, ' ');
-          f_types_impl_ << param_spec_function_name << " (\"" << member_name << "\"," << endl
-                        << args_indent << "NULL," << endl << args_indent << "NULL," << endl
-                        << args_indent << min_value << "," << endl << args_indent << max_value
-                        << "," << endl << args_indent << default_value.str() << "," << endl
-                        << args_indent << "G_PARAM_READWRITE));" << endl;
-        }
-
-        indent_down();
-      } else if (member_type->is_enum()) {
-        t_enum_value* enum_min_value = ((t_enum*)member_type)->get_min_value();
-        t_enum_value* enum_max_value = ((t_enum*)member_type)->get_max_value();
-        int min_value = (enum_min_value != NULL) ? enum_min_value->get_value() : 0;
-        int max_value = (enum_max_value != NULL) ? enum_max_value->get_value() : 0;
-
-        args_indent += string(18, ' ');
-        f_types_impl_ << "g_param_spec_int (\"" << member_name << "\"," << endl << args_indent
-                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent
-                      << min_value << "," << endl << args_indent << max_value << "," << endl
-                      << args_indent << min_value << "," << endl << args_indent
-                      << "G_PARAM_READWRITE));" << endl;
-        indent_down();
-      } else if (member_type->is_struct() || member_type->is_xception()) {
-        string param_type = this->nspace_uc + "TYPE_"
-                            + to_upper_case(initial_caps_to_underscores(member_type->get_name()));
-
-        args_indent += string(20, ' ');
-        f_types_impl_ << "g_param_spec_object (\"" << member_name << "\"," << endl << args_indent
-                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent
-                      << param_type << "," << endl << args_indent << "G_PARAM_READWRITE));" << endl;
-        indent_down();
-      } else if (member_type->is_list()) {
-        t_type* elem_type = ((t_list*)member_type)->get_elem_type();
-        string param_type;
-
-        if (elem_type->is_base_type() && !elem_type->is_string()) {
-          param_type = "G_TYPE_ARRAY";
-        } else {
-          param_type = "G_TYPE_PTR_ARRAY";
-        }
-
-        args_indent += string(20, ' ');
-        f_types_impl_ << "g_param_spec_boxed (\"" << member_name << "\"," << endl << args_indent
-                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent
-                      << param_type << "," << endl << args_indent << "G_PARAM_READWRITE));" << endl;
-        indent_down();
-      } else if (member_type->is_set() || member_type->is_map()) {
-        args_indent += string(20, ' ');
-        f_types_impl_ << "g_param_spec_boxed (\"" << member_name << "\"," << endl << args_indent
-                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent
-                      << "G_TYPE_HASH_TABLE," << endl << args_indent << "G_PARAM_READWRITE));"
-                      << endl;
-        indent_down();
-      }
-    }
-  }
-  scope_down(f_types_impl_);
-  f_types_impl_ << endl;
-
-  f_types_impl_ << "GType" << endl << this->nspace_lc << name_u << "_get_type (void)" << endl << "{"
-                << endl << "  static GType type = 0;" << endl << endl << "  if (type == 0) " << endl
-                << "  {" << endl << "    static const GTypeInfo type_info = " << endl << "    {"
-                << endl << "      sizeof (" << this->nspace << name << "Class)," << endl
-                << "      NULL, /* base_init */" << endl << "      NULL, /* base_finalize */"
-                << endl << "      (GClassInitFunc) " << this->nspace_lc << name_u << "_class_init,"
-                << endl << "      NULL, /* class_finalize */" << endl
-                << "      NULL, /* class_data */" << endl << "      sizeof (" << this->nspace
-                << name << ")," << endl << "      0, /* n_preallocs */" << endl
-                << "      (GInstanceInitFunc) " << this->nspace_lc << name_u << "_instance_init,"
-                << endl << "      NULL, /* value_table */" << endl << "    };" << endl << endl
-                << "    type = g_type_register_static (THRIFT_TYPE_STRUCT, " << endl
-                << "                                   \"" << this->nspace << name << "Type\","
-                << endl << "                                   &type_info, 0);" << endl << "  }"
-                << endl << endl << "  return type;" << endl << "}" << endl << endl;
-}
-
-/**
- * Generates functions to write Thrift structures to a stream.
- */
-void t_c_glib_generator::generate_struct_writer(ostream& out,
-                                                t_struct* tstruct,
-                                                string this_name,
-                                                string this_get,
-                                                bool is_function) {
-  string name = tstruct->get_name();
-  string name_u = initial_caps_to_underscores(name);
-  string name_uc = to_upper_case(name_u);
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  int error_ret = 0;
-
-  if (is_function) {
-    error_ret = -1;
-    indent(out) << "static gint32" << endl << this->nspace_lc << name_u
-                << "_write (ThriftStruct *object, ThriftProtocol *protocol, GError **error)"
-                << endl;
-  }
-  indent(out) << "{" << endl;
-  indent_up();
-
-  out << indent() << "gint32 ret;" << endl << indent() << "gint32 xfer = 0;" << endl << endl;
-
-  indent(out) << this_get << endl;
-  // satisfy -Wall in the case of an empty struct
-  if (!this_get.empty()) {
-    indent(out) << "THRIFT_UNUSED_VAR (this_object);" << endl;
-  }
-
-  out << indent() << "if ((ret = thrift_protocol_write_struct_begin (protocol, \"" << name
-      << "\", error)) < 0)" << endl << indent() << "  return " << error_ret << ";" << endl
-      << indent() << "xfer += ret;" << endl;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if ((*f_iter)->get_req() == t_field::T_OPTIONAL) {
-      indent(out) << "if (this_object->__isset_" << (*f_iter)->get_name() << " == TRUE) {" << endl;
-      indent_up();
-    }
-
-    out << indent() << "if ((ret = thrift_protocol_write_field_begin (protocol, "
-        << "\"" << (*f_iter)->get_name() << "\", " << type_to_enum((*f_iter)->get_type()) << ", "
-        << (*f_iter)->get_key() << ", error)) < 0)" << endl << indent() << "  return " << error_ret
-        << ";" << endl << indent() << "xfer += ret;" << endl;
-    generate_serialize_field(out, *f_iter, this_name, "", error_ret);
-    out << indent() << "if ((ret = thrift_protocol_write_field_end (protocol, error)) < 0)" << endl
-        << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;"
-        << endl;
-
-    if ((*f_iter)->get_req() == t_field::T_OPTIONAL) {
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-  }
-
-  // write the struct map
-  out << indent() << "if ((ret = thrift_protocol_write_field_stop (protocol, error)) < 0)" << endl
-      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl
-      << indent() << "if ((ret = thrift_protocol_write_struct_end (protocol, error)) < 0)" << endl
-      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl
-      << endl;
-
-  if (is_function) {
-    indent(out) << "return xfer;" << endl;
-  }
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Generates code to read Thrift structures from a stream.
- */
-void t_c_glib_generator::generate_struct_reader(ostream& out,
-                                                t_struct* tstruct,
-                                                string this_name,
-                                                string this_get,
-                                                bool is_function) {
-  string name = tstruct->get_name();
-  string name_u = initial_caps_to_underscores(name);
-  string name_uc = to_upper_case(name_u);
-  int error_ret = 0;
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  if (is_function) {
-    error_ret = -1;
-    indent(out) << "/* reads a " << name_u << " object */" << endl << "static gint32" << endl
-                << this->nspace_lc << name_u
-                << "_read (ThriftStruct *object, ThriftProtocol *protocol, GError **error)" << endl;
-  }
-
-  indent(out) << "{" << endl;
-  indent_up();
-
-  // declare stack temp variables
-  out << indent() << "gint32 ret;" << endl << indent() << "gint32 xfer = 0;" << endl << indent()
-      << "gchar *name = NULL;" << endl << indent() << "ThriftType ftype;" << endl << indent()
-      << "gint16 fid;" << endl << indent() << "guint32 len = 0;" << endl << indent()
-      << "gpointer data = NULL;" << endl << indent() << this_get << endl;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if ((*f_iter)->get_req() == t_field::T_REQUIRED) {
-      indent(out) << "gboolean isset_" << (*f_iter)->get_name() << " = FALSE;" << endl;
-    }
-  }
-
-  out << endl;
-
-  // satisfy -Wall in case we don't use some variables
-  out << indent() << "/* satisfy -Wall in case these aren't used */" << endl << indent()
-      << "THRIFT_UNUSED_VAR (len);" << endl << indent() << "THRIFT_UNUSED_VAR (data);" << endl;
-
-  if (!this_get.empty()) {
-    out << indent() << "THRIFT_UNUSED_VAR (this_object);" << endl;
-  }
-  out << endl;
-
-  // read the beginning of the structure marker
-  out << indent() << "/* read the struct begin marker */" << endl << indent()
-      << "if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)" << endl
-      << indent() << "{" << endl << indent() << "  if (name) g_free (name);" << endl << indent()
-      << "  return " << error_ret << ";" << endl << indent() << "}" << endl << indent()
-      << "xfer += ret;" << endl << indent() << "if (name) g_free (name);" << endl << indent()
-      << "name = NULL;" << endl << endl;
-
-  // read the struct fields
-  out << indent() << "/* read the struct fields */" << endl << indent() << "while (1)" << endl;
-  scope_up(out);
-
-  // read beginning field marker
-  out << indent() << "/* read the beginning of a field */" << endl << indent()
-      << "if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)"
-      << endl << indent() << "{" << endl << indent() << "  if (name) g_free (name);" << endl
-      << indent() << "  return " << error_ret << ";" << endl << indent() << "}" << endl << indent()
-      << "xfer += ret;" << endl << indent() << "if (name) g_free (name);" << endl << indent()
-      << "name = NULL;" << endl << endl;
-
-  // check for field STOP marker
-  out << indent() << "/* break if we get a STOP field */" << endl << indent()
-      << "if (ftype == T_STOP)" << endl << indent() << "{" << endl << indent() << "  break;" << endl
-      << indent() << "}" << endl << endl;
-
-  // switch depending on the field type
-  indent(out) << "switch (fid)" << endl;
-
-  // start switch
-  scope_up(out);
-
-  // generate deserialization code for known types
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl;
-    indent_up();
-    indent(out) << "if (ftype == " << type_to_enum((*f_iter)->get_type()) << ")" << endl;
-    indent(out) << "{" << endl;
-
-    indent_up();
-    // generate deserialize field
-    generate_deserialize_field(out, *f_iter, this_name, "", error_ret, false);
-    indent_down();
-
-    out << indent() << "} else {" << endl << indent()
-        << "  if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)" << endl << indent()
-        << "    return " << error_ret << ";" << endl << indent() << "  xfer += ret;" << endl
-        << indent() << "}" << endl << indent() << "break;" << endl;
-    indent_down();
-  }
-
-  // create the default case
-  out << indent() << "default:" << endl << indent()
-      << "  if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)" << endl << indent()
-      << "    return " << error_ret << ";" << endl << indent() << "  xfer += ret;" << endl
-      << indent() << "  break;" << endl;
-
-  // end switch
-  scope_down(out);
-
-  // read field end marker
-  out << indent() << "if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)" << endl
-      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl;
-
-  // end while loop
-  scope_down(out);
-  out << endl;
-
-  // read the end of the structure
-  out << indent() << "if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)" << endl
-      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl
-      << endl;
-
-  // if a required field is missing, throw an error
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if ((*f_iter)->get_req() == t_field::T_REQUIRED) {
-      out << indent() << "if (!isset_" << (*f_iter)->get_name() << ")" << endl << indent() << "{"
-          << endl << indent() << "  g_set_error (error, THRIFT_PROTOCOL_ERROR," << endl << indent()
-          << "               THRIFT_PROTOCOL_ERROR_INVALID_DATA," << endl << indent()
-          << "               \"missing field\");" << endl << indent() << "  return -1;" << endl
-          << indent() << "}" << endl << endl;
-    }
-  }
-
-  if (is_function) {
-    indent(out) << "return xfer;" << endl;
-  }
-
-  // end the function/structure
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-void t_c_glib_generator::generate_serialize_field(ostream& out,
-                                                  t_field* tfield,
-                                                  string prefix,
-                                                  string suffix,
-                                                  int error_ret) {
-  t_type* type = get_true_type(tfield->get_type());
-  string name = prefix + tfield->get_name() + suffix;
-
-  if (type->is_void()) {
-    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + name;
-  }
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_serialize_struct(out, (t_struct*)type, name, error_ret);
-  } else if (type->is_container()) {
-    generate_serialize_container(out, type, name, error_ret);
-  } else if (type->is_base_type() || type->is_enum()) {
-    indent(out) << "if ((ret = thrift_protocol_write_";
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + name;
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "bool (protocol, " << name;
-        break;
-      case t_base_type::TYPE_I8:
-        out << "byte (protocol, " << name;
-        break;
-      case t_base_type::TYPE_I16:
-        out << "i16 (protocol, " << name;
-        break;
-      case t_base_type::TYPE_I32:
-        out << "i32 (protocol, " << name;
-        break;
-      case t_base_type::TYPE_I64:
-        out << "i64 (protocol, " << name;
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "double (protocol, " << name;
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "binary (protocol, " << name << " ? ((GByteArray *) " << name << ")->data : NULL, "
-              << name << " ? ((GByteArray *) " << name << ")->len : 0";
-        } else {
-          out << "string (protocol, " << name;
-        }
-        break;
-      default:
-        throw "compiler error: no C writer for base type " + t_base_type::t_base_name(tbase) + name;
-      }
-    } else {
-      out << "i32 (protocol, (gint32) " << name;
-    }
-    out << ", error)) < 0)" << endl
-        << indent() << "  return " << error_ret << ";" << endl
-        << indent() << "xfer += ret;" << endl << endl;
-  } else {
-    throw std::logic_error("DO NOT KNOW HOW TO SERIALIZE FIELD '" + name + "' TYPE '"
-                           + type_name(type));
-  }
-}
-
-void t_c_glib_generator::generate_serialize_struct(ostream& out,
-                                                   t_struct* tstruct,
-                                                   string prefix,
-                                                   int error_ret) {
-  (void)tstruct;
-  out << indent() << "if ((ret = thrift_struct_write (THRIFT_STRUCT (" << prefix
-      << "), protocol, error)) < 0)" << endl << indent() << "  return " << error_ret << ";" << endl
-      << indent() << "xfer += ret;" << endl << endl;
-}
-
-void t_c_glib_generator::generate_serialize_container(ostream& out,
-                                                      t_type* ttype,
-                                                      string prefix,
-                                                      int error_ret) {
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    t_type* tkey = ((t_map*)ttype)->get_key_type();
-    t_type* tval = ((t_map*)ttype)->get_val_type();
-    string tkey_name = type_name(tkey);
-    string tval_name = type_name(tval);
-    string tkey_ptr;
-    string tval_ptr;
-    string keyname = tmp("key");
-    string valname = tmp("val");
-
-    declore_local_variable_for_write(out, tkey, keyname);
-    declore_local_variable_for_write(out, tval, valname);
-
-    /* If either the key or value type is a typedef, find its underlying type so
-       we can correctly determine how to generate a pointer to it */
-    tkey = get_true_type(tkey);
-    tval = get_true_type(tval);
-
-    tkey_ptr = tkey->is_string() || !tkey->is_base_type() ? "" : "*";
-    tval_ptr = tval->is_string() || !tval->is_base_type() ? "" : "*";
-
-    /*
-     * Some ugliness here.  To maximize backwards compatibility, we
-     * avoid using GHashTableIter and instead get a GList of all keys,
-     * then copy it into a array on the stack, and free it.
-     * This is because we may exit early before we get a chance to free the
-     * GList.
-     */
-    out << indent() << "GList *key_list = NULL, *iter = NULL;" << endl
-        << indent() << tkey_name << tkey_ptr << "* keys;" << endl
-        << indent() << "int i = 0, key_count;" << endl
-        << endl
-        << indent() << "if ((ret = thrift_protocol_write_map_begin (protocol, "
-        << type_to_enum(tkey) << ", " << type_to_enum(tval) << ", " << prefix << " ? "
-        << "(gint32) g_hash_table_size ((GHashTable *) " << prefix << ") : 0"
-        << ", error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl
-        << indent() << "if (" << prefix << ")" << endl
-        << indent() << "  g_hash_table_foreach ((GHashTable *) " << prefix
-        << ", thrift_hash_table_get_keys, &key_list);" << endl
-        << indent() << "key_count = g_list_length (key_list);" << endl
-        << indent() << "keys = g_newa (" << tkey_name << tkey_ptr
-        << ", key_count);" << endl
-        << indent() << "for (iter = g_list_first (key_list); iter; "
-           "iter = iter->next)" << endl;
-    indent_up();
-    out << indent() << "keys[i++] = (" << tkey_name << tkey_ptr
-        << ") iter->data;" << endl;
-    indent_down();
-    out << indent() << "g_list_free (key_list);" << endl
-        << endl
-        << indent() << "for (i = 0; i < key_count; ++i)" << endl;
-    scope_up(out);
-    out << indent() << keyname << " = keys[i];" << endl
-        << indent() << valname << " = (" << tval_name << tval_ptr
-        << ") g_hash_table_lookup (((GHashTable *) " << prefix
-        << "), (gpointer) " << keyname << ");" << endl
-        << endl;
-    generate_serialize_map_element(out,
-                                   (t_map*)ttype,
-                                   tkey_ptr + " " + keyname,
-                                   tval_ptr + " " + valname,
-                                   error_ret);
-    scope_down(out);
-    out << indent() << "if ((ret = thrift_protocol_write_map_end (protocol, "
-           "error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl;
-  } else if (ttype->is_set()) {
-    t_type* telem = ((t_set*)ttype)->get_elem_type();
-    string telem_name = type_name(telem);
-    string telem_ptr = telem->is_string() || !telem->is_base_type() ? "" : "*";
-    out << indent() << "GList *key_list = NULL, *iter = NULL;" << endl
-        << indent() << telem_name << telem_ptr << "* keys;" << endl
-        << indent() << "int i = 0, key_count;" << endl
-        << indent() << telem_name << telem_ptr << " elem;" << endl
-        << indent() << "gpointer value;" << endl
-        << indent() << "THRIFT_UNUSED_VAR (value);" << endl
-        << endl
-        << indent() << "if ((ret = thrift_protocol_write_set_begin (protocol, "
-        << type_to_enum(telem) << ", " << prefix << " ? "
-        << "(gint32) g_hash_table_size ((GHashTable *) " << prefix << ") : 0"
-        << ", error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl
-        << indent() << "if (" << prefix << ")" << endl
-        << indent() << "  g_hash_table_foreach ((GHashTable *) " << prefix
-        << ", thrift_hash_table_get_keys, &key_list);" << endl
-        << indent() << "key_count = g_list_length (key_list);" << endl
-        << indent() << "keys = g_newa (" << telem_name << telem_ptr
-        << ", key_count);" << endl
-        << indent() << "for (iter = g_list_first (key_list); iter; "
-           "iter = iter->next)" << endl;
-    indent_up();
-    out << indent() << "keys[i++] = (" << telem_name << telem_ptr
-        << ") iter->data;" << endl;
-    indent_down();
-    out << indent() << "g_list_free (key_list);" << endl
-        << endl
-        << indent() << "for (i = 0; i < key_count; ++i)" << endl;
-    scope_up(out);
-    out << indent() << "elem = keys[i];" << endl
-        << indent() << "value = (gpointer) g_hash_table_lookup "
-           "(((GHashTable *) " << prefix << "), (gpointer) elem);" << endl
-        << endl;
-    generate_serialize_set_element(out,
-                                   (t_set*)ttype,
-                                   telem_ptr + "elem",
-                                   error_ret);
-    scope_down(out);
-    out << indent() << "if ((ret = thrift_protocol_write_set_end (protocol, "
-           "error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl;
-  } else if (ttype->is_list()) {
-    string length = "(" + prefix + " ? " + prefix + "->len : 0)";
-    string i = tmp("i");
-    out << indent() << "guint " << i << ";" << endl
-        << endl
-        << indent() << "if ((ret = thrift_protocol_write_list_begin (protocol, "
-        << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", (gint32) "
-        << length << ", error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl
-        << indent() << "for (" << i << " = 0; " << i << " < " << length << "; "
-        << i << "++)" << endl;
-    scope_up(out);
-    generate_serialize_list_element(out, (t_list*)ttype, prefix, i, error_ret);
-    scope_down(out);
-    out << indent() << "if ((ret = thrift_protocol_write_list_end (protocol, "
-           "error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl;
-  }
-
-  scope_down(out);
-}
-
-void t_c_glib_generator::generate_serialize_map_element(ostream& out,
-                                                        t_map* tmap,
-                                                        string key,
-                                                        string value,
-                                                        int error_ret) {
-  t_field kfield(tmap->get_key_type(), key);
-  generate_serialize_field(out, &kfield, "", "", error_ret);
-
-  t_field vfield(tmap->get_val_type(), value);
-  generate_serialize_field(out, &vfield, "", "", error_ret);
-}
-
-void t_c_glib_generator::generate_serialize_set_element(ostream& out,
-                                                        t_set* tset,
-                                                        string element,
-                                                        int error_ret) {
-  t_field efield(tset->get_elem_type(), element);
-  generate_serialize_field(out, &efield, "", "", error_ret);
-}
-
-void t_c_glib_generator::generate_serialize_list_element(ostream& out,
-                                                         t_list* tlist,
-                                                         string list,
-                                                         string index,
-                                                         int error_ret) {
-  t_type* ttype = get_true_type(tlist->get_elem_type());
-
-  // cast to non-const
-  string cast = "";
-  string name = "g_ptr_array_index ((GPtrArray *) " + list + ", " + index + ")";
-
-  if (ttype->is_void()) {
-    throw std::runtime_error("compiler error: list element type cannot be void");
-  } else if (is_numeric(ttype)) {
-    name = "g_array_index (" + list + ", " + base_type_name(ttype) + ", " + index + ")";
-  } else if (ttype->is_string()) {
-    cast = "(gchar*)";
-  } else if (ttype->is_map() || ttype->is_set()) {
-    cast = "(GHashTable*)";
-  } else if (ttype->is_list()) {
-    t_type* etype = ((t_list*)ttype)->get_elem_type();
-    if (etype->is_void()) {
-      throw std::runtime_error("compiler error: list element type cannot be void");
-    }
-    cast = is_numeric(etype) ? "(GArray*)" : "(GPtrArray*)";
-  }
-
-  t_field efield(ttype, "(" + cast + name + ")");
-  generate_serialize_field(out, &efield, "", "", error_ret);
-}
-
-/* deserializes a field of any type. */
-void t_c_glib_generator::generate_deserialize_field(ostream& out,
-                                                    t_field* tfield,
-                                                    string prefix,
-                                                    string suffix,
-                                                    int error_ret,
-                                                    bool allocate) {
-  t_type* type = get_true_type(tfield->get_type());
-
-  if (type->is_void()) {
-    throw std::runtime_error("CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix
-                             + tfield->get_name());
-  }
-
-  string name = prefix + tfield->get_name() + suffix;
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_deserialize_struct(out, (t_struct*)type, name, error_ret, allocate);
-  } else if (type->is_container()) {
-    generate_deserialize_container(out, type, name, error_ret);
-  } else if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    if (tbase == t_base_type::TYPE_STRING) {
-      indent(out) << "if (" << name << " != NULL)" << endl << indent() << "{" << endl;
-      indent_up();
-      indent(out) << "g_free(" << name << ");" << endl << indent() << name << " = NULL;" << endl;
-      indent_down();
-      indent(out) << "}" << endl << endl;
-    }
-    indent(out) << "if ((ret = thrift_protocol_read_";
-
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "compiler error: cannot serialize void field in a struct: " + name;
-      break;
-    case t_base_type::TYPE_STRING:
-      if (type->is_binary()) {
-        out << "binary (protocol, &data, &len";
-      } else {
-        out << "string (protocol, &" << name;
-      }
-      break;
-    case t_base_type::TYPE_BOOL:
-      out << "bool (protocol, &" << name;
-      break;
-    case t_base_type::TYPE_I8:
-      out << "byte (protocol, &" << name;
-      break;
-    case t_base_type::TYPE_I16:
-      out << "i16 (protocol, &" << name;
-      break;
-    case t_base_type::TYPE_I32:
-      out << "i32 (protocol, &" << name;
-      break;
-    case t_base_type::TYPE_I64:
-      out << "i64 (protocol, &" << name;
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      out << "double (protocol, &" << name;
-      break;
-    default:
-      throw "compiler error: no C reader for base type " + t_base_type::t_base_name(tbase) + name;
-    }
-    out << ", error)) < 0)" << endl;
-    out << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;"
-        << endl;
-
-    // load the byte array with the data
-    if (tbase == t_base_type::TYPE_STRING && type->is_binary()) {
-      indent(out) << name << " = g_byte_array_new();" << endl;
-      indent(out) << "g_byte_array_append (" << name << ", (guint8 *) data, (guint) len);" << endl;
-      indent(out) << "g_free (data);" << endl;
-    }
-  } else if (type->is_enum()) {
-    string t = tmp("ecast");
-    out << indent() << "gint32 " << t << ";" << endl << indent()
-        << "if ((ret = thrift_protocol_read_i32 (protocol, &" << t << ", error)) < 0)" << endl
-        << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl
-        << indent() << name << " = (" << type_name(type) << ")" << t << ";" << endl;
-  } else {
-    throw std::logic_error("DO NOT KNOW HOW TO SERIALIZE FIELD '" + tfield->get_name() + "' TYPE '"
-                           + type_name(type));
-  }
-
-  // if the type is not required and this is a thrift struct (no prefix),
-  // set the isset variable.  if the type is required, then set the
-  // local variable indicating the value was set, so that we can do    // validation later.
-  if (prefix != "" && tfield->get_req() != t_field::T_REQUIRED) {
-    indent(out) << prefix << "__isset_" << tfield->get_name() << suffix << " = TRUE;" << endl;
-  } else if (prefix != "" && tfield->get_req() == t_field::T_REQUIRED) {
-    indent(out) << "isset_" << tfield->get_name() << " = TRUE;" << endl;
-  }
-}
-
-void t_c_glib_generator::generate_deserialize_struct(ostream& out,
-                                                     t_struct* tstruct,
-                                                     string prefix,
-                                                     int error_ret,
-                                                     bool allocate) {
-  string name_uc = to_upper_case(initial_caps_to_underscores(tstruct->get_name()));
-  if (tstruct->is_xception()) {
-    out << indent() << "/* This struct is an exception */" << endl;
-    allocate = true;
-  }
-
-  if (allocate) {
-    out << indent() << "if ( " << prefix << " != NULL)" << endl << indent() << "{" << endl;
-    indent_up();
-    out << indent() << "g_object_unref (" << prefix << ");" << endl;
-    indent_down();
-    out << indent() << "}" << endl << indent() << prefix << " = g_object_new (" << this->nspace_uc
-        << "TYPE_" << name_uc << ", NULL);" << endl;
-  }
-  out << indent() << "if ((ret = thrift_struct_read (THRIFT_STRUCT (" << prefix
-      << "), protocol, error)) < 0)" << endl << indent() << "{" << endl;
-  indent_up();
-  if (allocate) {
-    indent(out) << "g_object_unref (" << prefix << ");" << endl;
-    if (tstruct->is_xception()) {
-      indent(out) << prefix << " = NULL;" << endl;
-    }
-  }
-  out << indent() << "return " << error_ret << ";" << endl;
-  indent_down();
-  out << indent() << "}" << endl << indent() << "xfer += ret;" << endl;
-}
-
-void t_c_glib_generator::generate_deserialize_container(ostream& out,
-                                                        t_type* ttype,
-                                                        string prefix,
-                                                        int error_ret) {
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    out << indent() << "guint32 size;" << endl
-        << indent() << "guint32 i;" << endl
-        << indent() << "ThriftType key_type;" << endl
-        << indent() << "ThriftType value_type;" << endl
-        << endl
-        << indent() << "/* read the map begin marker */" << endl
-        << indent() << "if ((ret = thrift_protocol_read_map_begin (protocol, "
-           "&key_type, &value_type, &size, error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl
-        << endl;
-
-    // iterate over map elements
-    out << indent() << "/* iterate through each of the map's fields */" << endl
-        << indent() << "for (i = 0; i < size; i++)" << endl;
-    scope_up(out);
-    generate_deserialize_map_element(out, (t_map*)ttype, prefix, error_ret);
-    scope_down(out);
-    out << endl;
-
-    // read map end
-    out << indent() << "/* read the map end marker */" << endl
-        << indent() << "if ((ret = thrift_protocol_read_map_end (protocol, "
-           "error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl;
-  } else if (ttype->is_set()) {
-    out << indent() << "guint32 size;" << endl
-        << indent() << "guint32 i;" << endl
-        << indent() << "ThriftType element_type;" << endl
-        << endl
-        << indent() << "if ((ret = thrift_protocol_read_set_begin (protocol, "
-           "&element_type, &size, error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl
-        << endl;
-
-    // iterate over the elements
-    out << indent() << "/* iterate through the set elements */" << endl
-        << indent() << "for (i = 0; i < size; ++i)" << endl;
-    scope_up(out);
-    generate_deserialize_set_element(out, (t_set*)ttype, prefix, error_ret);
-    scope_down(out);
-
-    // read set end
-    out << indent() << "if ((ret = thrift_protocol_read_set_end (protocol, "
-           "error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl
-        << endl;
-  } else if (ttype->is_list()) {
-    out << indent() << "guint32 size;" << endl
-        << indent() << "guint32 i;" << endl
-        << indent() << "ThriftType element_type;" << endl
-        << endl
-        << indent() << "if ((ret = thrift_protocol_read_list_begin (protocol, "
-           "&element_type,&size, error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl
-        << endl;
-
-    // iterate over the elements
-    out << indent() << "/* iterate through list elements */" << endl
-        << indent() << "for (i = 0; i < size; i++)" << endl;
-    scope_up(out);
-    generate_deserialize_list_element(out,
-                                      (t_list*)ttype,
-                                      prefix,
-                                      "i",
-                                      error_ret);
-    scope_down(out);
-
-    // read list end
-    out << indent() << "if ((ret = thrift_protocol_read_list_end (protocol, "
-           "error)) < 0)" << endl;
-    indent_up();
-    out << indent() << "return " << error_ret << ";" << endl;
-    indent_down();
-    out << indent() << "xfer += ret;" << endl;
-  }
-
-  scope_down(out);
-}
-
-void t_c_glib_generator::declare_local_variable(ostream& out, t_type* ttype, string& name, bool for_hash_table) {
-  string tname = type_name(ttype);
-
-  /* If the given type is a typedef, find its underlying type so we
-     can correctly determine how to generate a pointer to it */
-  ttype = get_true_type(ttype);
-  string ptr = !is_numeric(ttype) ? "" : "*";
-
-  if (ttype->is_map()) {
-    t_map* tmap = (t_map*)ttype;
-    out << indent() << tname << ptr << " " << name << " = "
-        << generate_new_hash_from_type(tmap->get_key_type(), tmap->get_val_type()) << endl;
-  } else if (ttype->is_list()) {
-    t_list* tlist = (t_list*)ttype;
-    out << indent() << tname << ptr << " " << name << " = "
-        << generate_new_array_from_type(tlist->get_elem_type()) << endl;
-  } else if (for_hash_table && ttype->is_enum()) {
-    out << indent() << tname << " " << name << ";" << endl;
-  } else {
-    out << indent() << tname << ptr << " " << name
-        << (ptr != "" ? " = g_new (" + tname + ", 1)" : " = NULL") << ";" << endl;
-  }
-}
-
-void t_c_glib_generator::declore_local_variable_for_write(ostream& out,
-                                                          t_type* ttype,
-                                                          string& name) {
-  string tname = type_name(ttype);
-  ttype = get_true_type(ttype);
-  string ptr = ttype->is_string() || !ttype->is_base_type() ? " " : "* ";
-  string init_val = ttype->is_enum() ? "" : " = NULL";
-  out << indent() << tname << ptr << name << init_val << ";" << endl;
-}
-
-void t_c_glib_generator::generate_deserialize_map_element(ostream& out,
-                                                          t_map* tmap,
-                                                          string prefix,
-                                                          int error_ret) {
-  t_type* tkey = tmap->get_key_type();
-  t_type* tval = tmap->get_val_type();
-  string keyname = tmp("key");
-  string valname = tmp("val");
-
-  declare_local_variable(out, tkey, keyname, true);
-  declare_local_variable(out, tval, valname, true);
-
-  /* If either the key or value type is a typedef, find its underlying
-     type so we can correctly determine how to generate a pointer to
-     it */
-  tkey = get_true_type(tkey);
-  tval = get_true_type(tval);
-
-  string tkey_ptr = tkey->is_string() || !tkey->is_base_type() ? "" : "*";
-  string tval_ptr = tval->is_string() || !tval->is_base_type() ? "" : "*";
-
-  // deserialize the fields of the map element
-  t_field fkey(tkey, tkey_ptr + keyname);
-  generate_deserialize_field(out, &fkey, "", "", error_ret);
-  t_field fval(tval, tval_ptr + valname);
-  generate_deserialize_field(out, &fval, "", "", error_ret);
-
-  indent(out) << "if (" << prefix << " && " << keyname << ")" << endl;
-  indent_up();
-  indent(out) << "g_hash_table_insert ((GHashTable *)" << prefix << ", (gpointer) " << keyname
-              << ", (gpointer) " << valname << ");" << endl;
-  indent_down();
-}
-
-void t_c_glib_generator::generate_deserialize_set_element(ostream& out,
-                                                          t_set* tset,
-                                                          string prefix,
-                                                          int error_ret) {
-  t_type* telem = tset->get_elem_type();
-  string elem = tmp("_elem");
-  string telem_ptr = telem->is_string() || !telem->is_base_type() ? "" : "*";
-
-  declare_local_variable(out, telem, elem, true);
-
-  t_field felem(telem, telem_ptr + elem);
-  generate_deserialize_field(out, &felem, "", "", error_ret);
-
-  indent(out) << "if (" << prefix << " && " << elem << ")" << endl;
-  indent_up();
-  indent(out) << "g_hash_table_insert ((GHashTable *) " << prefix << ", (gpointer) " << elem
-              << ", (gpointer) " << elem << ");" << endl;
-  indent_down();
-}
-
-void t_c_glib_generator::generate_deserialize_list_element(ostream& out,
-                                                           t_list* tlist,
-                                                           string prefix,
-                                                           string index,
-                                                           int error_ret) {
-  (void)index;
-  t_type* ttype = get_true_type(tlist->get_elem_type());
-  string elem = tmp("_elem");
-  string telem_ptr = !is_numeric(ttype) ? "" : "*";
-
-  declare_local_variable(out, ttype, elem, false);
-
-  t_field felem(ttype, telem_ptr + elem);
-  generate_deserialize_field(out, &felem, "", "", error_ret);
-
-  if (ttype->is_void()) {
-    throw std::runtime_error("compiler error: list element type cannot be void");
-  } else if (is_numeric(ttype)) {
-    indent(out) << "g_array_append_vals (" << prefix << ", " << elem << ", 1);" << endl;
-  } else {
-    indent(out) << "g_ptr_array_add (" << prefix << ", " << elem << ");" << endl;
-  }
-}
-
-string t_c_glib_generator::generate_free_func_from_type(t_type* ttype) {
-  if (ttype == NULL)
-    return "NULL";
-
-  if (ttype->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "compiler error: cannot determine hash type";
-      break;
-    case t_base_type::TYPE_BOOL:
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-    case t_base_type::TYPE_I64:
-    case t_base_type::TYPE_DOUBLE:
-      return "g_free";
-    case t_base_type::TYPE_STRING:
-      if (((t_base_type*)ttype)->is_binary()) {
-        return "thrift_string_free";
-      }
-      return "g_free";
-    default:
-      throw "compiler error: no hash table info for type";
-    }
-  } else if (ttype->is_enum()) {
-    return "NULL";
-  } else if (ttype->is_map() || ttype->is_set()) {
-    return "(GDestroyNotify) thrift_safe_hash_table_destroy";
-  } else if (ttype->is_struct()) {
-    return "g_object_unref";
-  } else if (ttype->is_list()) {
-    t_type* etype = ((t_list*)ttype)->get_elem_type();
-    if (etype->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)etype)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot determine array type";
-        break;
-      case t_base_type::TYPE_BOOL:
-      case t_base_type::TYPE_I8:
-      case t_base_type::TYPE_I16:
-      case t_base_type::TYPE_I32:
-      case t_base_type::TYPE_I64:
-      case t_base_type::TYPE_DOUBLE:
-        return "(GDestroyNotify) g_array_unref";
-      case t_base_type::TYPE_STRING:
-        return "(GDestroyNotify) g_ptr_array_unref";
-      default:
-        throw "compiler error: no array info for type";
-      }
-    } else if (etype->is_container() || etype->is_struct()) {
-      return "(GDestroyNotify) g_ptr_array_unref";
-      ;
-    } else if (etype->is_enum()) {
-      return "(GDestroyNotify) g_array_unref";
-    }
-    printf("Type not expected inside the array: %s\n", etype->get_name().c_str());
-    throw "Type not expected inside array";
-  } else if (ttype->is_typedef()) {
-    return generate_free_func_from_type(((t_typedef*)ttype)->get_type());
-  }
-  printf("Type not expected: %s\n", ttype->get_name().c_str());
-  throw "Type not expected";
-}
-
-string t_c_glib_generator::generate_hash_func_from_type(t_type* ttype) {
-  if (ttype == NULL)
-    return "NULL";
-
-  if (ttype->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "compiler error: cannot determine hash type";
-      break;
-    case t_base_type::TYPE_BOOL:
-      return "thrift_boolean_hash";
-    case t_base_type::TYPE_I8:
-      return "thrift_int8_hash";
-    case t_base_type::TYPE_I16:
-      return "thrift_int16_hash";
-    case t_base_type::TYPE_I32:
-      return "g_int_hash";
-    case t_base_type::TYPE_I64:
-      return "g_int64_hash";
-    case t_base_type::TYPE_DOUBLE:
-      return "g_double_hash";
-    case t_base_type::TYPE_STRING:
-      return "g_str_hash";
-    default:
-      throw "compiler error: no hash table info for type";
-    }
-  } else if (ttype->is_enum()) {
-    return "g_direct_hash";
-  } else if (ttype->is_container() || ttype->is_struct()) {
-    return "g_direct_hash";
-  } else if (ttype->is_typedef()) {
-    return generate_hash_func_from_type(((t_typedef*)ttype)->get_type());
-  }
-  printf("Type not expected: %s\n", ttype->get_name().c_str());
-  throw "Type not expected";
-}
-
-string t_c_glib_generator::generate_cmp_func_from_type(t_type* ttype) {
-  if (ttype == NULL)
-    return "NULL";
-
-  if (ttype->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "compiler error: cannot determine hash type";
-      break;
-    case t_base_type::TYPE_BOOL:
-      return "thrift_boolean_equal";
-    case t_base_type::TYPE_I8:
-      return "thrift_int8_equal";
-    case t_base_type::TYPE_I16:
-      return "thrift_int16_equal";
-    case t_base_type::TYPE_I32:
-      return "g_int_equal";
-    case t_base_type::TYPE_I64:
-      return "g_int64_equal";
-    case t_base_type::TYPE_DOUBLE:
-      return "g_double_equal";
-    case t_base_type::TYPE_STRING:
-      return "g_str_equal";
-    default:
-      throw "compiler error: no hash table info for type";
-    }
-  } else if (ttype->is_enum()) {
-    return "g_direct_equal";
-  } else if (ttype->is_container() || ttype->is_struct()) {
-    return "g_direct_equal";
-  } else if (ttype->is_typedef()) {
-    return generate_cmp_func_from_type(((t_typedef*)ttype)->get_type());
-  }
-  printf("Type not expected: %s\n", ttype->get_name().c_str());
-  throw "Type not expected";
-}
-
-string t_c_glib_generator::generate_new_hash_from_type(t_type* key, t_type* value) {
-  string hash_func = generate_hash_func_from_type(key);
-  string cmp_func = generate_cmp_func_from_type(key);
-  string key_free_func = generate_free_func_from_type(key);
-  string value_free_func = generate_free_func_from_type(value);
-
-  return "g_hash_table_new_full (" + hash_func + ", " + cmp_func + ", " + key_free_func + ", "
-         + value_free_func + ");";
-}
-
-string t_c_glib_generator::generate_new_array_from_type(t_type* ttype) {
-  if (ttype->is_void()) {
-    throw std::runtime_error("compiler error: cannot determine array type");
-  } else if (is_numeric(ttype)) {
-    return "g_array_new (0, 1, sizeof (" + base_type_name(ttype) + "));";
-  } else {
-    string free_func = generate_free_func_from_type(ttype);
-    return "g_ptr_array_new_with_free_func (" + free_func + ");";
-  }
-}
-
-/***************************************
- * UTILITY FUNCTIONS                   *
- ***************************************/
-
-/**
- * Upper case a string.  Wraps boost's string utility.
- */
-string to_upper_case(string name) {
-  string s(name);
-  std::transform(s.begin(), s.end(), s.begin(), ::toupper);
-  return s;
-  //  return boost::to_upper_copy (name);
-}
-
-/**
- * Lower case a string.  Wraps boost's string utility.
- */
-string to_lower_case(string name) {
-  string s(name);
-  std::transform(s.begin(), s.end(), s.begin(), ::tolower);
-  return s;
-  //  return boost::to_lower_copy (name);
-}
-
-/**
- * Makes a string friendly to C code standards by lowercasing and adding
- * underscores, with the exception of the first character.  For example:
- *
- * Input: "ZomgCamelCase"
- * Output: "zomg_camel_case"
- */
-string initial_caps_to_underscores(string name) {
-  string ret;
-  const char* tmp = name.c_str();
-  int pos = 0;
-
-  /* the first character isn't underscored if uppercase, just lowercased */
-  ret += tolower(tmp[pos]);
-  pos++;
-  for (unsigned int i = pos; i < name.length(); i++) {
-    char lc = tolower(tmp[i]);
-    if (lc != tmp[i]) {
-      ret += '_';
-    }
-    ret += lc;
-  }
-
-  return ret;
-}
-
-/**
- * Performs the reverse operation of initial_caps_to_underscores: The first
- * character of the string is made uppercase, along with each character that
- * follows an underscore (which is removed). Useful for converting Thrift
- * service-method names into GObject-style class names.
- *
- * Input: "zomg_camel_case"
- * Output: "ZomgCamelCase"
- */
-string underscores_to_initial_caps(string name) {
-  string ret;
-  const char* tmp = name.c_str();
-  bool uppercase_next = true;
-
-  for (unsigned int i = 0; i < name.length(); i++) {
-    char c = tmp[i];
-    if (c == '_') {
-      uppercase_next = true;
-    } else {
-      if (uppercase_next) {
-        ret += toupper(c);
-        uppercase_next = false;
-      } else {
-        ret += c;
-      }
-    }
-  }
-
-  return ret;
-}
-
-/* register this generator with the main program */
-THRIFT_REGISTER_GENERATOR(c_glib, "C, using GLib", "")
+/* 
+ * 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. 
+ * 
+ * Contains some contributions under the Thrift Software License. 
+ * Please see doc/old-thrift-license.txt in the Thrift distribution for 
+ * details. 
+ */ 
+ 
+#include <fstream> 
+#include <iostream> 
+#include <stdexcept> 
+#include <string> 
+#include <vector> 
+ 
+#include <ctype.h> 
+ 
+#include "thrift/platform.h" 
+#include "thrift/generate/t_oop_generator.h" 
+ 
+using std::map; 
+using std::ostream; 
+using std::ostringstream; 
+using std::string; 
+using std::stringstream; 
+using std::vector; 
+ 
+static const string endl = "\n"; // avoid ostream << std::endl flushes 
+ 
+/* forward declarations */ 
+string initial_caps_to_underscores(string name); 
+string underscores_to_initial_caps(string name); 
+string to_upper_case(string name); 
+string to_lower_case(string name); 
+ 
+/** 
+ * C code generator, using glib for C typing. 
+ */ 
+class t_c_glib_generator : public t_oop_generator { 
+public: 
+  /* constructor */ 
+  t_c_glib_generator(t_program* program, 
+                     const map<string, string>& parsed_options, 
+                     const string& option_string) 
+    : t_oop_generator(program) { 
+    (void)option_string; 
+    std::map<std::string, std::string>::const_iterator iter; 
+ 
+    /* set the output directory */ 
+    this->out_dir_base_ = "gen-c_glib"; 
+ 
+    /* no options yet */ 
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) { 
+      throw "unknown option c_glib:" + iter->first; 
+    } 
+ 
+    /* set the namespace */ 
+    this->nspace = program_->get_namespace("c_glib"); 
+ 
+    if (this->nspace.empty()) { 
+      this->nspace = ""; 
+      this->nspace_u = ""; 
+      this->nspace_uc = ""; 
+      this->nspace_lc = ""; 
+    } else { 
+      /* replace dots with underscores */ 
+      char* tmp = strdup(this->nspace.c_str()); 
+      for (unsigned int i = 0; i < strlen(tmp); i++) { 
+        if (tmp[i] == '.') { 
+          tmp[i] = '_'; 
+        } 
+      } 
+      this->nspace = string(tmp, strlen(tmp)); 
+      free(tmp); 
+ 
+      /* clean up the namespace for C. 
+       * An input of 'namespace foo' should result in: 
+       *  - nspace = foo       - for thrift objects and typedefs 
+       *  - nspace_u = Foo     - for internal GObject prefixes 
+       *  - nspace_uc = FOO_   - for macro prefixes 
+       *  - nspace_lc = foo_   - for filename and method prefixes 
+       * The underscores are there since uc and lc strings are used as file and 
+       * variable prefixes. 
+       */ 
+      this->nspace_u = initial_caps_to_underscores(this->nspace); 
+      this->nspace_uc = to_upper_case(this->nspace_u) + "_"; 
+      this->nspace_lc = to_lower_case(this->nspace_u) + "_"; 
+    } 
+  } 
+ 
+  /* initialization and destruction */ 
+  void init_generator(); 
+  void close_generator(); 
+ 
+  /* generation functions */ 
+  void generate_typedef(t_typedef* ttypedef); 
+  void generate_enum(t_enum* tenum); 
+  void generate_consts(vector<t_const*> consts); 
+  void generate_struct(t_struct* tstruct); 
+  void generate_service(t_service* tservice); 
+  void generate_xception(t_struct* tstruct); 
+ 
+private: 
+  /* file streams */ 
+  ofstream_with_content_based_conditional_update f_types_; 
+  ofstream_with_content_based_conditional_update f_types_impl_; 
+  ofstream_with_content_based_conditional_update f_header_; 
+  ofstream_with_content_based_conditional_update f_service_; 
+ 
+  /* namespace variables */ 
+  string nspace; 
+  string nspace_u; 
+  string nspace_uc; 
+  string nspace_lc; 
+ 
+  /* helper functions */ 
+  bool is_complex_type(t_type* ttype); 
+  bool is_numeric(t_type* ttype); 
+  string type_name(t_type* ttype, bool in_typedef = false, bool is_const = false); 
+  string property_type_name(t_type* ttype, bool in_typedef = false, bool is_const = false); 
+  string base_type_name(t_type* type); 
+  string type_to_enum(t_type* type); 
+  string constant_literal(t_type* type, t_const_value* value); 
+  string constant_value(string name, t_type* type, t_const_value* value); 
+  string constant_value_with_storage(string name, t_type* type, t_const_value* value); 
+  string function_signature(t_function* tfunction); 
+  string argument_list(t_struct* tstruct); 
+  string xception_list(t_struct* tstruct); 
+  string declare_field(t_field* tfield, 
+                       bool init = false, 
+                       bool pointer = false, 
+                       bool constant = false, 
+                       bool reference = false); 
+  void declare_local_variable(ostream& out, t_type* ttype, string& base_name, bool for_hash_table); 
+  void declore_local_variable_for_write(ostream& out, t_type* ttype, string& base_name); 
+ 
+  /* generation functions */ 
+  void generate_const_initializer(string name, 
+                                  t_type* type, 
+                                  t_const_value* value, 
+                                  bool top_level = false); 
+  void generate_service_helpers(t_service* tservice); 
+  void generate_service_client(t_service* tservice); 
+  void generate_service_handler(t_service* tservice); 
+  void generate_service_processor(t_service* tservice); 
+  void generate_service_server(t_service* tservice); 
+  void generate_object(t_struct* tstruct); 
+  void generate_struct_writer(ostream& out, 
+                              t_struct* tstruct, 
+                              string this_name, 
+                              string this_get = "", 
+                              bool is_function = true); 
+  void generate_struct_reader(ostream& out, 
+                              t_struct* tstruct, 
+                              string this_name, 
+                              string this_get = "", 
+                              bool is_function = true); 
+ 
+  void generate_serialize_field(ostream& out, 
+                                t_field* tfield, 
+                                string prefix, 
+                                string suffix, 
+                                int error_ret); 
+  void generate_serialize_struct(ostream& out, t_struct* tstruct, string prefix, int error_ret); 
+  void generate_serialize_container(ostream& out, t_type* ttype, string prefix, int error_ret); 
+  void generate_serialize_map_element(ostream& out, 
+                                      t_map* tmap, 
+                                      string key, 
+                                      string value, 
+                                      int error_ret); 
+  void generate_serialize_set_element(ostream& out, t_set* tset, string element, int error_ret); 
+  void generate_serialize_list_element(ostream& out, 
+                                       t_list* tlist, 
+                                       string list, 
+                                       string index, 
+                                       int error_ret); 
+ 
+  void generate_deserialize_field(ostream& out, 
+                                  t_field* tfield, 
+                                  string prefix, 
+                                  string suffix, 
+                                  int error_ret, 
+                                  bool allocate = true); 
+  void generate_deserialize_struct(ostream& out, 
+                                   t_struct* tstruct, 
+                                   string prefix, 
+                                   int error_ret, 
+                                   bool allocate = true); 
+  void generate_deserialize_container(ostream& out, t_type* ttype, string prefix, int error_ret); 
+  void generate_deserialize_map_element(ostream& out, t_map* tmap, string prefix, int error_ret); 
+  void generate_deserialize_set_element(ostream& out, t_set* tset, string prefix, int error_ret); 
+  void generate_deserialize_list_element(ostream& out, 
+                                         t_list* tlist, 
+                                         string prefix, 
+                                         string index, 
+                                         int error_ret); 
+ 
+  string generate_new_hash_from_type(t_type* key, t_type* value); 
+  string generate_new_array_from_type(t_type* ttype); 
+ 
+  string generate_free_func_from_type(t_type* ttype); 
+  string generate_hash_func_from_type(t_type* ttype); 
+  string generate_cmp_func_from_type(t_type* ttype); 
+}; 
+ 
+/** 
+ * Prepare for file generation by opening up the necessary file 
+ * output streams. 
+ */ 
+void t_c_glib_generator::init_generator() { 
+  /* create output directory */ 
+  MKDIR(get_out_dir().c_str()); 
+ 
+  string program_name_u = initial_caps_to_underscores(program_name_); 
+  string program_name_uc = to_upper_case(program_name_u); 
+  string program_name_lc = to_lower_case(program_name_u); 
+ 
+  /* create output files */ 
+  string f_types_name = get_out_dir() + this->nspace_lc + program_name_lc + "_types.h"; 
+  f_types_.open(f_types_name.c_str()); 
+  string f_types_impl_name = get_out_dir() + this->nspace_lc + program_name_lc + "_types.c"; 
+  f_types_impl_.open(f_types_impl_name.c_str()); 
+ 
+  /* add thrift boilerplate headers */ 
+  f_types_ << autogen_comment(); 
+  f_types_impl_ << autogen_comment(); 
+ 
+  /* include inclusion guard */ 
+  f_types_ << "#ifndef " << this->nspace_uc << program_name_uc << "_TYPES_H" << endl << "#define " 
+           << this->nspace_uc << program_name_uc << "_TYPES_H" << endl << endl; 
+ 
+  /* include base types */ 
+  f_types_ << "/* base includes */" << endl << "#include <glib-object.h>" << endl 
+           << "#include <thrift/c_glib/thrift_struct.h>" << endl 
+           << "#include <thrift/c_glib/protocol/thrift_protocol.h>" << endl; 
+ 
+  /* include other thrift includes */ 
+  const vector<t_program*>& includes = program_->get_includes(); 
+  for (size_t i = 0; i < includes.size(); ++i) { 
+    f_types_ << "/* other thrift includes */" << endl << "#include \"" << this->nspace_lc 
+             << initial_caps_to_underscores(includes[i]->get_name()) << "_types.h\"" << endl; 
+  } 
+  f_types_ << endl; 
+ 
+  /* include custom headers */ 
+  const vector<string>& c_includes = program_->get_c_includes(); 
+  f_types_ << "/* custom thrift includes */" << endl; 
+  for (size_t i = 0; i < c_includes.size(); ++i) { 
+    if (c_includes[i][0] == '<') { 
+      f_types_ << "#include " << c_includes[i] << endl; 
+    } else { 
+      f_types_ << "#include \"" << c_includes[i] << "\"" << endl; 
+    } 
+  } 
+  f_types_ << endl; 
+ 
+  /* include math.h (for "INFINITY") in the implementation file, in case we 
+     encounter a struct with a member of type double */ 
+  f_types_impl_ << endl << "#include <math.h>" << endl; 
+ 
+  // include the types file 
+  f_types_impl_ << endl << "#include \"" << this->nspace_lc << program_name_u << "_types.h\"" 
+                << endl << "#include <thrift/c_glib/thrift.h>" << endl << endl; 
+ 
+  f_types_ << "/* begin types */" << endl << endl; 
+} 
+ 
+/** 
+ *  Finish up generation and close all file streams. 
+ */ 
+void t_c_glib_generator::close_generator() { 
+  string program_name_uc = to_upper_case(initial_caps_to_underscores(program_name_)); 
+ 
+  /* end the header inclusion guard */ 
+  f_types_ << "#endif /* " << this->nspace_uc << program_name_uc << "_TYPES_H */" << endl; 
+ 
+  /* close output file */ 
+  f_types_.close(); 
+  f_types_impl_.close(); 
+} 
+ 
+/** 
+ * Generates a Thrift typedef in C code.  For example: 
+ * 
+ * Thrift: 
+ * typedef map<i32,i32> SomeMap 
+ * 
+ * C: 
+ * typedef GHashTable * ThriftSomeMap; 
+ */ 
+void t_c_glib_generator::generate_typedef(t_typedef* ttypedef) { 
+  f_types_ << indent() << "typedef " << type_name(ttypedef->get_type(), true) << " " << this->nspace 
+           << ttypedef->get_symbolic() << ";" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a C enumeration.  For example: 
+ * 
+ * Thrift: 
+ * enum MyEnum { 
+ *   ONE = 1, 
+ *   TWO 
+ * } 
+ * 
+ * C: 
+ * enum _ThriftMyEnum { 
+ *   THRIFT_MY_ENUM_ONE = 1, 
+ *   THRIFT_MY_ENUM_TWO 
+ * }; 
+ * typedef enum _ThriftMyEnum ThriftMyEnum; 
+ */ 
+void t_c_glib_generator::generate_enum(t_enum* tenum) { 
+  string name = tenum->get_name(); 
+  string name_uc = to_upper_case(initial_caps_to_underscores(name)); 
+ 
+  f_types_ << indent() << "enum _" << this->nspace << name << " {" << endl; 
+ 
+  indent_up(); 
+ 
+  vector<t_enum_value*> constants = tenum->get_constants(); 
+  vector<t_enum_value*>::iterator c_iter; 
+  bool first = true; 
+ 
+  /* output each of the enumeration elements */ 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      f_types_ << "," << endl; 
+    } 
+ 
+    f_types_ << indent() << this->nspace_uc << name_uc << "_" << (*c_iter)->get_name(); 
+    f_types_ << " = " << (*c_iter)->get_value(); 
+  } 
+ 
+  indent_down(); 
+  f_types_ << endl << "};" << endl << "typedef enum _" << this->nspace << name << " " 
+           << this->nspace << name << ";" << endl << endl; 
+ 
+  f_types_ << "/* return the name of the constant */" << endl; 
+  f_types_ << "const char *" << endl; 
+  f_types_ << "toString_" << name << "(int value); " << endl << endl; 
+  ; 
+  f_types_impl_ << "/* return the name of the constant */" << endl; 
+  f_types_impl_ << "const char *" << endl; 
+  f_types_impl_ << "toString_" << name << "(int value) " << endl; 
+  f_types_impl_ << "{" << endl; 
+  f_types_impl_ << "  static __thread char buf[16] = {0};" << endl; 
+  f_types_impl_ << "  switch(value) {" << endl; 
+  std::set<int> done; 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    int value = (*c_iter)->get_value(); 
+    // Skipping duplicate value 
+    if (done.find(value) == done.end()) { 
+      done.insert(value); 
+      f_types_impl_ << "  case " << this->nspace_uc << name_uc << "_" << (*c_iter)->get_name() 
+                    << ":" 
+                    << "return \"" << this->nspace_uc << name_uc << "_" << (*c_iter)->get_name() 
+                    << "\";" << endl; 
+    } 
+  } 
+  f_types_impl_ << "  default: g_snprintf(buf, 16, \"%d\", value); return buf;" << endl; 
+  f_types_impl_ << "  }" << endl; 
+  f_types_impl_ << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates Thrift constants in C code. 
+ */ 
+void t_c_glib_generator::generate_consts(vector<t_const*> consts) { 
+  f_types_ << "/* constants */" << endl; 
+  f_types_impl_ << "/* constants */" << endl; 
+ 
+  vector<t_const*>::iterator c_iter; 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    string name = (*c_iter)->get_name(); 
+    string name_uc = to_upper_case(name); 
+    string name_lc = to_lower_case(name); 
+    t_type* type = (*c_iter)->get_type(); 
+    t_const_value* value = (*c_iter)->get_value(); 
+ 
+    if (is_complex_type(type)) { 
+      f_types_ << type_name(type) << indent() << this->nspace_lc << name_lc 
+               << "_constant();" << endl; 
+    } 
+ 
+    f_types_ << indent() << "#define " << this->nspace_uc << name_uc << " " 
+             << constant_value(name_lc, type, value) << endl; 
+ 
+    generate_const_initializer(name_lc, type, value, true); 
+  } 
+ 
+  f_types_ << endl; 
+  f_types_impl_ << endl; 
+} 
+ 
+/** 
+ * Generate Thrift structs in C code, as GObjects.  Example: 
+ * 
+ * Thrift: 
+ * struct Bonk 
+ * { 
+ *   1: string message, 
+ *   2: i32 type 
+ * } 
+ * 
+ * C GObject instance header: 
+ * struct _ThriftBonk 
+ * { 
+ *   GObject parent; 
+ * 
+ *   gchar * message; 
+ *   gint32 type; 
+ * }; 
+ * typedef struct _ThriftBonk ThriftBonk 
+ * // ... additional GObject boilerplate ... 
+ */ 
+void t_c_glib_generator::generate_struct(t_struct* tstruct) { 
+  f_types_ << "/* struct " << tstruct->get_name() << " */" << endl; 
+  generate_object(tstruct); 
+} 
+ 
+/** 
+ * Generate C code to represent Thrift services.  Creates a new GObject 
+ * which can be used to access the service. 
+ */ 
+void t_c_glib_generator::generate_service(t_service* tservice) { 
+  string svcname_u = initial_caps_to_underscores(tservice->get_name()); 
+  string svcname_uc = this->nspace_uc + to_upper_case(svcname_u); 
+  string filename = this->nspace_lc + to_lower_case(svcname_u); 
+ 
+  // make output files 
+  string f_header_name = get_out_dir() + filename + ".h"; 
+  f_header_.open(f_header_name.c_str()); 
+ 
+  string program_name_u = initial_caps_to_underscores(program_name_); 
+  string program_name_lc = to_lower_case(program_name_u); 
+ 
+  // add header file boilerplate 
+  f_header_ << autogen_comment(); 
+ 
+  // add an inclusion guard 
+  f_header_ << "#ifndef " << svcname_uc << "_H" << endl << "#define " << svcname_uc << "_H" << endl 
+            << endl; 
+ 
+  // add standard includes 
+  f_header_ << "#include <thrift/c_glib/processor/thrift_dispatch_processor.h>" << endl << endl; 
+  f_header_ << "#include \"" << this->nspace_lc << program_name_lc << "_types.h\"" << endl; 
+ 
+  // if we are inheriting from another service, include its header 
+  t_service* extends_service = tservice->get_extends(); 
+  if (extends_service != NULL) { 
+    f_header_ << "#include \"" << this->nspace_lc 
+              << to_lower_case(initial_caps_to_underscores(extends_service->get_name())) << ".h\"" 
+              << endl; 
+  } 
+  f_header_ << endl; 
+ 
+  // create the service implementation 
+  string f_service_name = get_out_dir() + filename + ".c"; 
+  f_service_.open(f_service_name.c_str()); 
+ 
+  // add the boilerplace header 
+  f_service_ << autogen_comment(); 
+ 
+  // include the headers 
+  f_service_ << "#include <string.h>" << endl << "#include <thrift/c_glib/thrift.h>" << endl 
+             << "#include <thrift/c_glib/thrift_application_exception.h>" << endl << "#include \"" 
+             << filename << ".h\"" << endl << endl; 
+ 
+  // generate the service-helper classes 
+  generate_service_helpers(tservice); 
+ 
+  // generate the client objects 
+  generate_service_client(tservice); 
+ 
+  // generate the server objects 
+  generate_service_server(tservice); 
+ 
+  // end the header inclusion guard 
+  f_header_ << "#endif /* " << svcname_uc << "_H */" << endl; 
+ 
+  // close the files 
+  f_service_.close(); 
+  f_header_.close(); 
+} 
+ 
+/** 
+ * 
+ */ 
+void t_c_glib_generator::generate_xception(t_struct* tstruct) { 
+  string name = tstruct->get_name(); 
+  string name_u = initial_caps_to_underscores(name); 
+  string name_lc = to_lower_case(name_u); 
+  string name_uc = to_upper_case(name_u); 
+ 
+  generate_object(tstruct); 
+ 
+  f_types_ << "/* exception */" << endl 
+           << "typedef enum" << endl 
+           << "{" << endl; 
+  indent_up(); 
+  f_types_ << indent() << this->nspace_uc << name_uc << "_ERROR_CODE" << endl; 
+  indent_down(); 
+  f_types_ << "} " << this->nspace << name << "Error;" << endl 
+           << endl 
+           << "GQuark " << this->nspace_lc << name_lc 
+           << "_error_quark (void);" << endl 
+           << "#define " << this->nspace_uc << name_uc << "_ERROR (" 
+           << this->nspace_lc << name_lc << "_error_quark())" << endl 
+           << endl 
+           << endl; 
+ 
+  f_types_impl_ << "/* define the GError domain for exceptions */" << endl << "#define " 
+                << this->nspace_uc << name_uc << "_ERROR_DOMAIN \"" << this->nspace_lc << name_lc 
+                << "_error_quark\"" << endl << "GQuark" << endl << this->nspace_lc << name_lc 
+                << "_error_quark (void)" << endl << "{" << endl 
+                << "  return g_quark_from_static_string (" << this->nspace_uc << name_uc 
+                << "_ERROR_DOMAIN);" << endl << "}" << endl << endl; 
+} 
+ 
+/******************** 
+ * HELPER FUNCTIONS * 
+ ********************/ 
+ 
+/** 
+ * Returns true if ttype is not a primitive. 
+ */ 
+bool t_c_glib_generator::is_complex_type(t_type* ttype) { 
+  ttype = get_true_type(ttype); 
+ 
+  return ttype->is_container() || ttype->is_struct() || ttype->is_xception(); 
+} 
+ 
+bool t_c_glib_generator::is_numeric(t_type* ttype) { 
+  return ttype->is_enum() || (ttype->is_base_type() && !ttype->is_string()); 
+} 
+ 
+/** 
+ * Maps a Thrift t_type to a C type. 
+ */ 
+string t_c_glib_generator::type_name(t_type* ttype, bool in_typedef, bool is_const) { 
+  if (ttype->is_base_type()) { 
+    string bname = base_type_name(ttype); 
+ 
+    if (is_const) { 
+      return "const " + bname; 
+    } else { 
+      return bname; 
+    } 
+  } 
+ 
+  if (ttype->is_container()) { 
+    string cname; 
+ 
+    t_container* tcontainer = (t_container*)ttype; 
+    if (tcontainer->has_cpp_name()) { 
+      cname = tcontainer->get_cpp_name(); 
+    } else if (ttype->is_map()) { 
+      cname = "GHashTable"; 
+    } else if (ttype->is_set()) { 
+      // since a set requires unique elements, use a GHashTable, and 
+      // populate the keys and values with the same data, using keys for 
+      // the actual writes and reads. 
+      // TODO: discuss whether or not to implement TSet, THashSet or GHashSet 
+      cname = "GHashTable"; 
+    } else if (ttype->is_list()) { 
+      t_type* etype = ((t_list*)ttype)->get_elem_type(); 
+      if (etype->is_void()) { 
+        throw std::runtime_error("compiler error: list element type cannot be void"); 
+      } 
+      // TODO: investigate other implementations besides GPtrArray 
+      cname = is_numeric(etype) ? "GArray" : "GPtrArray"; 
+    } 
+ 
+    /* Omit the dereference operator if we are aliasing this type within a 
+       typedef, to allow the type to be used more naturally in client code; 
+       otherwise, include it */ 
+    if (!in_typedef) { 
+      cname += " *"; 
+    } 
+ 
+    if (is_const) { 
+      return "const " + cname; 
+    } else { 
+      return cname; 
+    } 
+  } 
+ 
+  // check for a namespace 
+  string pname = this->nspace + ttype->get_name(); 
+ 
+  if (is_complex_type(ttype)) { 
+    pname += " *"; 
+  } 
+ 
+  if (is_const) { 
+    return "const " + pname; 
+  } else { 
+    return pname; 
+  } 
+} 
+ 
+/** 
+ * Maps a Thrift primitive to the type needed to hold its value when used as an 
+ * object property. 
+ * 
+ * This method is needed because all integer properties of width less than 64 
+ * bits map to the same type, gint, as opposed to their width-specific type 
+ * (gint8, gint16 or gint32). 
+ */ 
+string t_c_glib_generator::property_type_name(t_type* ttype, bool in_typedef, bool is_const) { 
+  string result; 
+ 
+  if (ttype->is_base_type()) { 
+    switch (((t_base_type*)ttype)->get_base()) { 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+      if (is_const) { 
+        result = "const gint"; 
+      } else { 
+        result = "gint"; 
+      } 
+      break; 
+ 
+    default: 
+      result = type_name(ttype, in_typedef, is_const); 
+    } 
+  } else { 
+    result = type_name(ttype, in_typedef, is_const); 
+  } 
+ 
+  return result; 
+} 
+ 
+/** 
+ * Maps a Thrift primitive to a C primitive. 
+ */ 
+string t_c_glib_generator::base_type_name(t_type* type) { 
+  if (type->is_enum()) { 
+    return type_name(type); 
+  } 
+  if (!type->is_base_type()) { 
+    throw std::invalid_argument("Only base types are suppported."); 
+  } 
+  t_base_type* base_type = reinterpret_cast<t_base_type*>(type); 
+  t_base_type::t_base tbase = base_type->get_base(); 
+  switch (tbase) { 
+  case t_base_type::TYPE_VOID: 
+    return "void"; 
+  case t_base_type::TYPE_STRING: 
+    if (base_type->is_binary()) { 
+      return "GByteArray *"; 
+    } else { 
+      return "gchar *"; 
+    } 
+  case t_base_type::TYPE_BOOL: 
+    return "gboolean"; 
+  case t_base_type::TYPE_I8: 
+    return "gint8"; 
+  case t_base_type::TYPE_I16: 
+    return "gint16"; 
+  case t_base_type::TYPE_I32: 
+    return "gint32"; 
+  case t_base_type::TYPE_I64: 
+    return "gint64"; 
+  case t_base_type::TYPE_DOUBLE: 
+    return "gdouble"; 
+  default: 
+    throw std::logic_error("compiler error: no C base type name for base type " 
+                           + t_base_type::t_base_name(tbase)); 
+  } 
+} 
+ 
+/** 
+ * Returns a member of the ThriftType C enumeration in thrift_protocol.h 
+ * for a Thrift type. 
+ */ 
+string t_c_glib_generator::type_to_enum(t_type* type) { 
+  type = get_true_type(type); 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+ 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "NO T_VOID CONSTRUCT"; 
+    case t_base_type::TYPE_STRING: 
+      return "T_STRING"; 
+    case t_base_type::TYPE_BOOL: 
+      return "T_BOOL"; 
+    case t_base_type::TYPE_I8: 
+      return "T_BYTE"; 
+    case t_base_type::TYPE_I16: 
+      return "T_I16"; 
+    case t_base_type::TYPE_I32: 
+      return "T_I32"; 
+    case t_base_type::TYPE_I64: 
+      return "T_I64"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "T_DOUBLE"; 
+    } 
+  } else if (type->is_enum()) { 
+    return "T_I32"; 
+  } else if (type->is_struct()) { 
+    return "T_STRUCT"; 
+  } else if (type->is_xception()) { 
+    return "T_STRUCT"; 
+  } else if (type->is_map()) { 
+    return "T_MAP"; 
+  } else if (type->is_set()) { 
+    return "T_SET"; 
+  } else if (type->is_list()) { 
+    return "T_LIST"; 
+  } 
+ 
+  throw "INVALID TYPE IN type_to_enum: " + type->get_name(); 
+} 
+ 
+/** 
+ * Returns a Thrift constant formatted as a literal for inclusion in C code. 
+ */ 
+string t_c_glib_generator::constant_literal(t_type* type, t_const_value* value) { 
+  ostringstream render; 
+ 
+  if (type->is_base_type()) { 
+    /* primitives */ 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+ 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      render << "\"" + value->get_string() + "\""; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      render << ((value->get_integer() != 0) ? "TRUE" : "FALSE"); 
+      break; 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+    case t_base_type::TYPE_I64: 
+      render << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      render << value->get_double(); 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else { 
+    t_const_value::t_const_value_type value_type = value->get_type(); 
+ 
+    switch (value_type) { 
+    case t_const_value::CV_IDENTIFIER: 
+      render << value->get_integer(); 
+      break; 
+    case t_const_value::CV_LIST: 
+      render << "{ "; 
+      { 
+        t_type* elem_type = ((t_list*)type)->get_elem_type(); 
+        const vector<t_const_value*>& list = value->get_list(); 
+        vector<t_const_value*>::const_iterator list_iter; 
+ 
+        if (list.size() > 0) { 
+          list_iter = list.begin(); 
+          render << constant_literal(elem_type, *list_iter); 
+ 
+          while (++list_iter != list.end()) { 
+            render << ", " << constant_literal(elem_type, *list_iter); 
+          } 
+        } 
+      } 
+      render << " }"; 
+      break; 
+    case t_const_value::CV_MAP: 
+    default: 
+      render << "NULL /* not supported */"; 
+    } 
+  } 
+ 
+  return render.str(); 
+} 
+ 
+/** 
+ * Returns C code that represents a Thrift constant. 
+ */ 
+string t_c_glib_generator::constant_value(string name, t_type* type, t_const_value* value) { 
+  ostringstream render; 
+ 
+  if (type->is_base_type()) { 
+    /* primitives */ 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      render << "g_strdup (\"" + value->get_string() + "\")"; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      render << ((value->get_integer() != 0) ? 1 : 0); 
+      break; 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+      render << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_I64: 
+      render << "G_GINT64_CONSTANT (" << value->get_integer() << ")"; 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      if (value->get_type() == t_const_value::CV_INTEGER) { 
+        render << value->get_integer(); 
+      } else { 
+        render << value->get_double(); 
+      } 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else if (type->is_enum()) { 
+    render << "(" << type_name(type) << ")" << value->get_integer(); 
+  } else if (is_complex_type(type)) { 
+    render << "(" << this->nspace_lc << to_lower_case(name) << "_constant())"; 
+  } else { 
+    render << "NULL /* not supported */"; 
+  } 
+ 
+  return render.str(); 
+} 
+ 
+/** 
+ * Renders a function signature of the form 'type name(args)' 
+ * 
+ * @param tfunction Function definition 
+ * @return String of rendered function definition 
+ */ 
+string t_c_glib_generator::function_signature(t_function* tfunction) { 
+  t_type* ttype = tfunction->get_returntype(); 
+  t_struct* arglist = tfunction->get_arglist(); 
+  t_struct* xlist = tfunction->get_xceptions(); 
+  string fname = initial_caps_to_underscores(tfunction->get_name()); 
+ 
+  bool has_return = !ttype->is_void(); 
+  bool has_args = arglist->get_members().size() == 0; 
+  bool has_xceptions = xlist->get_members().size() == 0; 
+  return "gboolean " + this->nspace_lc + fname + " (" + this->nspace + service_name_ + "If * iface" 
+         + (has_return ? ", " + type_name(ttype) + "* _return" : "") 
+         + (has_args ? "" : (", " + argument_list(arglist))) 
+         + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError ** error)"; 
+} 
+ 
+/** 
+ * Renders a field list 
+ * 
+ * @param tstruct The struct definition 
+ * @return Comma sepearated list of all field names in that struct 
+ */ 
+string t_c_glib_generator::argument_list(t_struct* tstruct) { 
+  string result = ""; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      result += ", "; 
+    } 
+    result += type_name((*f_iter)->get_type(), false, true) + " " + (*f_iter)->get_name(); 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Renders mutable exception lists 
+ * 
+ * @param tstruct The struct definition 
+ * @return Comma sepearated list of all field names in that struct 
+ */ 
+string t_c_glib_generator::xception_list(t_struct* tstruct) { 
+  string result = ""; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      result += ", "; 
+    } 
+    result += type_name((*f_iter)->get_type(), false, false) + "* " + (*f_iter)->get_name(); 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Declares a field, including any necessary initialization. 
+ */ 
+string t_c_glib_generator::declare_field(t_field* tfield, 
+                                         bool init, 
+                                         bool pointer, 
+                                         bool constant, 
+                                         bool reference) { 
+  string result = ""; 
+  if (constant) { 
+    result += "const "; 
+  } 
+  result += type_name(tfield->get_type()); 
+  if (pointer) { 
+    result += "*"; 
+  } 
+  if (reference) { 
+    result += "*"; 
+  } 
+  result += " " + tfield->get_name(); 
+  if (init) { 
+    t_type* type = get_true_type(tfield->get_type()); 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+      case t_base_type::TYPE_I8: 
+      case t_base_type::TYPE_I16: 
+      case t_base_type::TYPE_I32: 
+      case t_base_type::TYPE_I64: 
+        result += " = 0"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        result += " = (gdouble) 0"; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        result += " = NULL"; 
+        break; 
+      default: 
+        throw "compiler error: no C intializer for base type " + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      result += " = (" + type_name(type) + ") 0"; 
+    } else if (type->is_struct() || type->is_container()) { 
+      result += " = NULL"; 
+    } 
+  } 
+ 
+  if (!reference) { 
+    result += ";"; 
+  } 
+ 
+  return result; 
+} 
+ 
+string t_c_glib_generator::constant_value_with_storage(string fname, 
+                                                       t_type* etype, 
+                                                       t_const_value* value) { 
+  ostringstream render; 
+  if (is_numeric(etype)) { 
+    render << "    " << type_name(etype) << " *" << fname << " = " 
+           << "g_new (" << base_type_name(etype) << ", 1);" << endl 
+           << "    *" << fname << " = " << constant_value(fname, (t_type*)etype, value) << ";" 
+           << endl; 
+  } else { 
+    render << "    " << type_name(etype) << " " << fname << " = " 
+           << constant_value(fname, (t_type*)etype, value) << ";" << endl; 
+  } 
+  return render.str(); 
+} 
+ 
+/** 
+ * Generates C code that initializes complex constants. 
+ */ 
+void t_c_glib_generator::generate_const_initializer(string name, 
+                                                    t_type* type, 
+                                                    t_const_value* value, 
+                                                    bool top_level) { 
+  string name_u = initial_caps_to_underscores(name); 
+  string name_lc = to_lower_case(name_u); 
+  string type_u = initial_caps_to_underscores(type->get_name()); 
+  string type_uc = to_upper_case(type_u); 
+  string maybe_static = top_level ? "" : "static "; 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    const vector<t_field*>& fields = ((t_struct*)type)->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    ostringstream initializers; 
+ 
+    // initialize any constants that may be referenced by this initializer 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      t_type* field_type = NULL; 
+      string field_name = ""; 
+ 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field_type = (*f_iter)->get_type(); 
+          field_name = (*f_iter)->get_name(); 
+          break; 
+        } 
+      } 
+      if (field_type == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " 
+          + v_iter->first->get_string(); 
+      } 
+      field_name = tmp(field_name); 
+ 
+      generate_const_initializer(name + "_constant_" + field_name, 
+                                 field_type, 
+                                 v_iter->second); 
+      initializers << "    constant->" << v_iter->first->get_string() << " = " 
+                   << constant_value(name + "_constant_" + field_name, 
+                                     field_type, 
+                                     v_iter->second) << ";" << endl 
+                   << "    constant->__isset_" << v_iter->first->get_string() 
+                   << " = TRUE;" << endl; 
+    } 
+ 
+    // implement the initializer 
+    f_types_impl_ << maybe_static << this->nspace << type->get_name() << " *" 
+                  << endl 
+                  << this->nspace_lc << name_lc << "_constant (void)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << indent() << "static " << this->nspace << type->get_name() 
+                  << " *constant = NULL;" << endl 
+                  << indent() << "if (constant == NULL)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << indent() << "constant = g_object_new (" << this->nspace_uc 
+                  << "TYPE_" << type_uc << ", NULL);" << endl 
+                  << initializers.str(); 
+    scope_down(f_types_impl_); 
+ 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      t_type* field_type = NULL; 
+      string field_name = ""; 
+ 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field_type = (*f_iter)->get_type(); 
+          field_name = (*f_iter)->get_name(); 
+          break; 
+        } 
+      } 
+      if (field_type == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " 
+          + v_iter->first->get_string(); 
+      } 
+      field_name = tmp(field_name); 
+    } 
+ 
+    f_types_impl_ << indent() << "return constant;" << endl; 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << endl; 
+  } else if (type->is_list()) { 
+    string list_type = "GPtrArray *"; 
+    string free_func 
+        = generate_free_func_from_type(reinterpret_cast<t_list*>(type)->get_elem_type()); 
+    string list_initializer = "g_ptr_array_new_with_free_func (" + free_func + ");"; 
+    string list_appender = "g_ptr_array_add"; 
+    bool list_variable = false; 
+ 
+    t_type* etype = ((t_list*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    ostringstream initializers; 
+    ostringstream appenders; 
+ 
+    list_initializer = generate_new_array_from_type(etype); 
+    if (etype->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)etype)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot determine array type"; 
+      case t_base_type::TYPE_BOOL: 
+      case t_base_type::TYPE_I8: 
+      case t_base_type::TYPE_I16: 
+      case t_base_type::TYPE_I32: 
+      case t_base_type::TYPE_I64: 
+      case t_base_type::TYPE_DOUBLE: 
+        list_type = "GArray *"; 
+        list_appender = "g_array_append_val"; 
+        list_variable = true; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        break; 
+      default: 
+        throw "compiler error: no array info for type"; 
+      } 
+    } else if (etype->is_enum()) { 
+      list_type = "GArray *"; 
+      list_appender = "g_array_append_val"; 
+      list_variable = true; 
+    } 
+ 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string fname = tmp(name); 
+ 
+      generate_const_initializer(fname, etype, (*v_iter)); 
+      if (list_variable) { 
+        initializers << "    " << type_name(etype) << " " << fname << " = " 
+                     << constant_value(fname, (t_type*)etype, (*v_iter)) << ";" 
+                     << endl; 
+        appenders << "    " << list_appender << "(constant, " << fname << ");" 
+                  << endl; 
+      } else { 
+        appenders << "    " << list_appender << "(constant, " 
+                  << constant_value(fname, (t_type*)etype, (*v_iter)) << ");" 
+                  << endl; 
+      } 
+    } 
+ 
+    f_types_impl_ << maybe_static << list_type << endl 
+                  << this->nspace_lc << name_lc << "_constant (void)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << indent() << "static " << list_type << " constant = NULL;" 
+                  << endl 
+                  << indent() << "if (constant == NULL)" << endl; 
+    scope_up(f_types_impl_); 
+    if (!initializers.str().empty()) { 
+      f_types_impl_ << initializers.str() 
+                    << endl; 
+    } 
+    f_types_impl_ << indent() << "constant = " << list_initializer << endl 
+                  << appenders.str(); 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << indent() << "return constant;" << endl; 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << endl; 
+  } else if (type->is_set()) { 
+    t_type* etype = ((t_set*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    ostringstream initializers; 
+    ostringstream appenders; 
+ 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string fname = tmp(name); 
+      string ptr = is_numeric(etype) ? "*" : ""; 
+      generate_const_initializer(fname, etype, (*v_iter)); 
+      initializers << constant_value_with_storage(fname, (t_type*)etype, *v_iter); 
+      appenders << "    g_hash_table_insert (constant, " << fname << ", 0);" << endl; 
+    } 
+ 
+    f_types_impl_ << maybe_static << "GHashTable *" << endl 
+                  << this->nspace_lc << name_lc << "_constant (void)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << indent() << "static GHashTable *constant = NULL;" << endl 
+                  << indent() << "if (constant == NULL)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << initializers.str() << endl 
+                  << indent() << "constant = " << generate_new_hash_from_type(etype, NULL) << endl 
+                  << appenders.str(); 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << indent() << "return constant;" << endl; 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << endl; 
+  } else if (type->is_map()) { 
+    t_type* ktype = ((t_map*)type)->get_key_type(); 
+    t_type* vtype = ((t_map*)type)->get_val_type(); 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    ostringstream initializers; 
+    ostringstream appenders; 
+ 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string fname = tmp(name); 
+      string kname = fname + "key"; 
+      string vname = fname + "val"; 
+      generate_const_initializer(kname, ktype, v_iter->first); 
+      generate_const_initializer(vname, vtype, v_iter->second); 
+ 
+      initializers << constant_value_with_storage(kname, (t_type*)ktype, v_iter->first); 
+      initializers << constant_value_with_storage(vname, (t_type*)vtype, v_iter->second); 
+      appenders << "    g_hash_table_insert (constant, " << kname << ", " << vname << ");" << endl; 
+    } 
+ 
+    f_types_impl_ << maybe_static << "GHashTable *" << endl 
+                  << this->nspace_lc << name_lc << "_constant (void)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << indent() << "static GHashTable *constant = NULL;" << endl 
+                  << indent() << "if (constant == NULL)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << initializers.str() << endl 
+                  << indent() << "constant = " << generate_new_hash_from_type(ktype, vtype) << endl 
+                  << appenders.str(); 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << indent() << "return constant;" << endl; 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << endl; 
+  } 
+} 
+ 
+/** 
+ * Generates helper classes for a service, consisting of a ThriftStruct subclass 
+ * for the arguments to and the result from each method. 
+ * 
+ * @param tservice The service for which to generate helper classes 
+ */ 
+void t_c_glib_generator::generate_service_helpers(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator function_iter; 
+ 
+  // Iterate through the service's methods 
+  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) { 
+    string function_name = (*function_iter)->get_name(); 
+    t_struct* arg_list = (*function_iter)->get_arglist(); 
+    string arg_list_name_orig = arg_list->get_name(); 
+ 
+    // Generate the arguments class 
+    arg_list->set_name(tservice->get_name() + underscores_to_initial_caps(function_name) + "Args"); 
+    generate_struct(arg_list); 
+ 
+    arg_list->set_name(arg_list_name_orig); 
+ 
+    // Generate the result class 
+    if (!(*function_iter)->is_oneway()) { 
+      t_struct result(program_, 
+                      tservice->get_name() + underscores_to_initial_caps(function_name) + "Result"); 
+      t_field success((*function_iter)->get_returntype(), "success", 0); 
+      success.set_req(t_field::T_OPTIONAL); 
+      if (!(*function_iter)->get_returntype()->is_void()) { 
+        result.append(&success); 
+      } 
+ 
+      t_struct* xs = (*function_iter)->get_xceptions(); 
+      const vector<t_field*>& fields = xs->get_members(); 
+      vector<t_field*>::const_iterator field_iter; 
+      for (field_iter = fields.begin(); field_iter != fields.end(); ++field_iter) { 
+        (*field_iter)->set_req(t_field::T_OPTIONAL); 
+        result.append(*field_iter); 
+      } 
+ 
+      generate_struct(&result); 
+    } 
+  } 
+} 
+ 
+/** 
+ * Generates C code that represents a Thrift service client. 
+ */ 
+void t_c_glib_generator::generate_service_client(t_service* tservice) { 
+  /* get some C friendly service names */ 
+  string service_name_lc = to_lower_case(initial_caps_to_underscores(service_name_)); 
+  string service_name_uc = to_upper_case(service_name_lc); 
+ 
+  string parent_service_name; 
+  string parent_service_name_lc; 
+  string parent_service_name_uc; 
+ 
+  string parent_class_name = "GObject"; 
+  string parent_type_name = "G_TYPE_OBJECT"; 
+ 
+  // The service this service extends, or NULL if it extends no 
+  // service 
+  t_service* extends_service = tservice->get_extends(); 
+  if (extends_service) { 
+    // The name of the parent service 
+    parent_service_name = extends_service->get_name(); 
+    parent_service_name_lc = to_lower_case(initial_caps_to_underscores(parent_service_name)); 
+    parent_service_name_uc = to_upper_case(parent_service_name_lc); 
+ 
+    // The names of the client class' parent class and type 
+    parent_class_name = this->nspace + parent_service_name + "Client"; 
+    parent_type_name = this->nspace_uc + "TYPE_" + parent_service_name_uc + "_CLIENT"; 
+  } 
+ 
+  // The base service (the topmost in the "extends" hierarchy), on 
+  // whose client class the "input_protocol" and "output_protocol" 
+  // properties are defined 
+  t_service* base_service = tservice; 
+  while (base_service->get_extends()) { 
+    base_service = base_service->get_extends(); 
+  } 
+ 
+  string base_service_name = base_service->get_name(); 
+  string base_service_name_lc = to_lower_case(initial_caps_to_underscores(base_service_name)); 
+  string base_service_name_uc = to_upper_case(base_service_name_lc); 
+ 
+  // Generate the client interface dummy object in the header. 
+  f_header_ << "/* " << service_name_ << " service interface */" << endl << "typedef struct _" 
+            << this->nspace << service_name_ << "If " << this->nspace << service_name_ << "If; " 
+            << " /* dummy object */" << endl << endl; 
+ 
+  // Generate the client interface object in the header. 
+  f_header_ << "struct _" << this->nspace << service_name_ << "IfInterface" << endl << "{" << endl 
+            << "  GTypeInterface parent;" << endl << endl; 
+ 
+  /* write out the functions for this interface */ 
+  indent_up(); 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    /* make the function name C friendly */ 
+    string funname = initial_caps_to_underscores((*f_iter)->get_name()); 
+    t_type* ttype = (*f_iter)->get_returntype(); 
+    t_struct* arglist = (*f_iter)->get_arglist(); 
+    t_struct* xlist = (*f_iter)->get_xceptions(); 
+    bool has_return = !ttype->is_void(); 
+    bool has_args = arglist->get_members().size() == 0; 
+    bool has_xceptions = xlist->get_members().size() == 0; 
+ 
+    string params = "(" + this->nspace + service_name_ + "If *iface" 
+                    + (has_return ? ", " + type_name(ttype) + "* _return" : "") 
+                    + (has_args ? "" : (", " + argument_list(arglist))) 
+                    + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError **error)"; 
+ 
+    indent(f_header_) << "gboolean (*" << funname << ") " << params << ";" << endl; 
+  } 
+  indent_down(); 
+ 
+  f_header_ << "};" << endl << "typedef struct _" << this->nspace << service_name_ << "IfInterface " 
+            << this->nspace << service_name_ << "IfInterface;" << endl << endl; 
+ 
+  // generate all the interface boilerplate 
+  f_header_ << "GType " << this->nspace_lc << service_name_lc << "_if_get_type (void);" << endl 
+            << "#define " << this->nspace_uc << "TYPE_" << service_name_uc << "_IF " 
+            << "(" << this->nspace_lc << service_name_lc << "_if_get_type())" << endl << "#define " 
+            << this->nspace_uc << service_name_uc << "_IF(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_IF, " << this->nspace << service_name_ << "If))" << endl 
+            << "#define " << this->nspace_uc << "IS_" << service_name_uc << "_IF(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_IF))" << endl << "#define " << this->nspace_uc 
+            << service_name_uc << "_IF_GET_INTERFACE(inst) (G_TYPE_INSTANCE_GET_INTERFACE ((inst), " 
+            << this->nspace_uc << "TYPE_" << service_name_uc << "_IF, " << this->nspace 
+            << service_name_ << "IfInterface))" << endl << endl; 
+ 
+  // write out all the interface function prototypes 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    /* make the function name C friendly */ 
+    string funname = initial_caps_to_underscores((*f_iter)->get_name()); 
+    t_type* ttype = (*f_iter)->get_returntype(); 
+    t_struct* arglist = (*f_iter)->get_arglist(); 
+    t_struct* xlist = (*f_iter)->get_xceptions(); 
+    bool has_return = !ttype->is_void(); 
+    bool has_args = arglist->get_members().size() == 0; 
+    bool has_xceptions = xlist->get_members().size() == 0; 
+ 
+    string params = "(" + this->nspace + service_name_ + "If *iface" 
+                    + (has_return ? ", " + type_name(ttype) + "* _return" : "") 
+                    + (has_args ? "" : (", " + argument_list(arglist))) 
+                    + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError **error)"; 
+ 
+    f_header_ << "gboolean " << this->nspace_lc << service_name_lc << "_if_" << funname << " " 
+              << params << ";" << endl; 
+  } 
+  f_header_ << endl; 
+ 
+  // Generate the client object instance definition in the header. 
+  f_header_ << "/* " << service_name_ << " service client */" << endl << "struct _" << this->nspace 
+            << service_name_ << "Client" << endl << "{" << endl << "  " << parent_class_name 
+            << " parent;" << endl; 
+  if (!extends_service) { 
+    // Define "input_protocol" and "output_protocol" properties only 
+    // for base services; child service-client classes will inherit 
+    // these 
+    f_header_ << endl << "  ThriftProtocol *input_protocol;" << endl 
+              << "  ThriftProtocol *output_protocol;" << endl; 
+  } 
+  f_header_ << "};" << endl << "typedef struct _" << this->nspace << service_name_ << "Client " 
+            << this->nspace << service_name_ << "Client;" << endl << endl; 
+ 
+  // Generate the class definition in the header. 
+  f_header_ << "struct _" << this->nspace << service_name_ << "ClientClass" << endl << "{" << endl 
+            << "  " << parent_class_name << "Class parent;" << endl << "};" << endl 
+            << "typedef struct _" << this->nspace << service_name_ << "ClientClass " << this->nspace 
+            << service_name_ << "ClientClass;" << endl << endl; 
+ 
+  // Create all the GObject boilerplate 
+  f_header_ << "GType " << this->nspace_lc << service_name_lc << "_client_get_type (void);" << endl 
+            << "#define " << this->nspace_uc << "TYPE_" << service_name_uc << "_CLIENT " 
+            << "(" << this->nspace_lc << service_name_lc << "_client_get_type())" << endl 
+            << "#define " << this->nspace_uc << service_name_uc << "_CLIENT(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_CLIENT, " << this->nspace << service_name_ << "Client))" << endl 
+            << "#define " << this->nspace_uc << service_name_uc << "_CLIENT_CLASS(c) " 
+            << "(G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "TYPE_" << service_name_uc 
+            << "_CLIENT, " << this->nspace << service_name_ << "ClientClass))" << endl << "#define " 
+            << this->nspace_uc << service_name_uc << "_IS_CLIENT(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_CLIENT))" << endl << "#define " << this->nspace_uc 
+            << service_name_uc << "_IS_CLIENT_CLASS(c) " 
+            << "(G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc << "TYPE_" << service_name_uc 
+            << "_CLIENT))" << endl << "#define " << this->nspace_uc << service_name_uc 
+            << "_CLIENT_GET_CLASS(obj) " 
+            << "(G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_CLIENT, " << this->nspace << service_name_ << "ClientClass))" 
+            << endl << endl; 
+ 
+  /* write out the function prototypes */ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    /* make the function name C friendly */ 
+    string funname = to_lower_case(initial_caps_to_underscores((*f_iter)->get_name())); 
+ 
+    t_function service_function((*f_iter)->get_returntype(), 
+                                service_name_lc + string("_client_") + funname, 
+                                (*f_iter)->get_arglist(), 
+                                (*f_iter)->get_xceptions()); 
+    indent(f_header_) << function_signature(&service_function) << ";" << endl; 
+ 
+    t_function send_function(g_type_void, 
+                             service_name_lc + string("_client_send_") + funname, 
+                             (*f_iter)->get_arglist()); 
+    indent(f_header_) << function_signature(&send_function) << ";" << endl; 
+ 
+    // implement recv if not a oneway service 
+    if (!(*f_iter)->is_oneway()) { 
+      t_struct noargs(program_); 
+      t_function recv_function((*f_iter)->get_returntype(), 
+                               service_name_lc + string("_client_recv_") + funname, 
+                               &noargs, 
+                               (*f_iter)->get_xceptions()); 
+      indent(f_header_) << function_signature(&recv_function) << ";" << endl; 
+    } 
+  } 
+ 
+  /* write out the get/set function prototypes */ 
+  f_header_ << "void " + service_name_lc + "_client_set_property (GObject *object, guint " 
+                                           "property_id, const GValue *value, GParamSpec *pspec);" 
+            << endl; 
+  f_header_ << "void " + service_name_lc + "_client_get_property (GObject *object, guint " 
+                                           "property_id, GValue *value, GParamSpec *pspec);" 
+            << endl; 
+ 
+  f_header_ << endl; 
+  // end of header code 
+ 
+  // Generate interface method implementations 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    /* make the function name C friendly */ 
+    string funname = initial_caps_to_underscores((*f_iter)->get_name()); 
+    t_type* ttype = (*f_iter)->get_returntype(); 
+    t_struct* arglist = (*f_iter)->get_arglist(); 
+    t_struct* xlist = (*f_iter)->get_xceptions(); 
+    bool has_return = !ttype->is_void(); 
+    bool has_args = arglist->get_members().size() == 0; 
+    bool has_xceptions = xlist->get_members().size() == 0; 
+ 
+    string params = "(" + this->nspace + service_name_ + "If *iface" 
+                    + (has_return ? ", " + type_name(ttype) + "* _return" : "") 
+                    + (has_args ? "" : (", " + argument_list(arglist))) 
+                    + (has_xceptions ? "" : (", " + xception_list(xlist))) + ", GError **error)"; 
+ 
+    string params_without_type = string("iface, ") + (has_return ? "_return, " : ""); 
+ 
+    const vector<t_field*>& fields = arglist->get_members(); 
+    vector<t_field*>::const_iterator f_iter_field; 
+    for (f_iter_field = fields.begin(); f_iter_field != fields.end(); ++f_iter_field) { 
+      params_without_type += (*f_iter_field)->get_name(); 
+      params_without_type += ", "; 
+    } 
+ 
+    const vector<t_field*>& xceptions = xlist->get_members(); 
+    vector<t_field*>::const_iterator x_iter; 
+    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+      params_without_type += (*x_iter)->get_name(); 
+      params_without_type += ", "; 
+    } 
+ 
+    f_service_ << "gboolean" << endl << this->nspace_lc << service_name_lc << "_if_" << funname 
+               << " " << params << endl << "{" << endl << "  return " << this->nspace_uc 
+               << service_name_uc << "_IF_GET_INTERFACE (iface)->" << funname << " (" 
+               << params_without_type << "error);" << endl << "}" << endl << endl; 
+  } 
+ 
+  // Generate interface boilerplate 
+  f_service_ << "GType" << endl << this->nspace_lc << service_name_lc << "_if_get_type (void)" 
+             << endl << "{" << endl << "  static GType type = 0;" << endl << "  if (type == 0)" 
+             << endl << "  {" << endl << "    static const GTypeInfo type_info =" << endl << "    {" 
+             << endl << "      sizeof (" << this->nspace << service_name_ << "IfInterface)," << endl 
+             << "      NULL,  /* base_init */" << endl << "      NULL,  /* base_finalize */" << endl 
+             << "      NULL,  /* class_init */" << endl << "      NULL,  /* class_finalize */" 
+             << endl << "      NULL,  /* class_data */" << endl 
+             << "      0,     /* instance_size */" << endl << "      0,     /* n_preallocs */" 
+             << endl << "      NULL,  /* instance_init */" << endl 
+             << "      NULL   /* value_table */" << endl << "    };" << endl 
+             << "    type = g_type_register_static (G_TYPE_INTERFACE," << endl 
+             << "                                   \"" << this->nspace << service_name_ << "If\"," 
+             << endl << "                                   &type_info, 0);" << endl << "  }" 
+             << endl << "  return type;" << endl << "}" << endl << endl; 
+ 
+  // Generate client boilerplate 
+  f_service_ << "static void " << endl << this->nspace_lc << service_name_lc 
+             << "_if_interface_init (" << this->nspace << service_name_ << "IfInterface *iface);" 
+             << endl << endl << "G_DEFINE_TYPE_WITH_CODE (" << this->nspace << service_name_ 
+             << "Client, " << this->nspace_lc << service_name_lc << "_client," << endl 
+             << "                         " << parent_type_name << ", " << endl 
+             << "                         G_IMPLEMENT_INTERFACE (" << this->nspace_uc << "TYPE_" 
+             << service_name_uc << "_IF," << endl 
+             << "                                                " << this->nspace_lc 
+             << service_name_lc << "_if_interface_init))" << endl << endl; 
+ 
+  // Generate property-related code only for base services---child 
+  // service-client classes have only properties inherited from their 
+  // parent class 
+  if (!extends_service) { 
+    // Generate client properties 
+    f_service_ << "enum _" << this->nspace << service_name_ << "ClientProperties" << endl << "{" 
+               << endl << "  PROP_0," << endl << "  PROP_" << this->nspace_uc << service_name_uc 
+               << "_CLIENT_INPUT_PROTOCOL," << endl << "  PROP_" << this->nspace_uc 
+               << service_name_uc << "_CLIENT_OUTPUT_PROTOCOL" << endl << "};" << endl << endl; 
+ 
+    // generate property setter 
+    f_service_ << "void" << endl << this->nspace_lc << service_name_lc << "_client_set_property (" 
+               << "GObject *object, guint property_id, const GValue *value, " 
+               << "GParamSpec *pspec)" << endl << "{" << endl << "  " << this->nspace 
+               << service_name_ << "Client *client = " << this->nspace_uc << service_name_uc 
+               << "_CLIENT (object);" << endl << endl << "  THRIFT_UNUSED_VAR (pspec);" << endl 
+               << endl << "  switch (property_id)" << endl << "  {" << endl << "    case PROP_" 
+               << this->nspace_uc << service_name_uc << "_CLIENT_INPUT_PROTOCOL:" << endl 
+               << "      client->input_protocol = g_value_get_object (value);" << endl 
+               << "      break;" << endl << "    case PROP_" << this->nspace_uc << service_name_uc 
+               << "_CLIENT_OUTPUT_PROTOCOL:" << endl 
+               << "      client->output_protocol = g_value_get_object (value);" << endl 
+               << "      break;" << endl << "  }" << endl << "}" << endl << endl; 
+ 
+    // generate property getter 
+    f_service_ << "void" << endl << this->nspace_lc << service_name_lc << "_client_get_property (" 
+               << "GObject *object, guint property_id, GValue *value, " 
+               << "GParamSpec *pspec)" << endl << "{" << endl << "  " << this->nspace 
+               << service_name_ << "Client *client = " << this->nspace_uc << service_name_uc 
+               << "_CLIENT (object);" << endl << endl << "  THRIFT_UNUSED_VAR (pspec);" << endl 
+               << endl << "  switch (property_id)" << endl << "  {" << endl << "    case PROP_" 
+               << this->nspace_uc << service_name_uc << "_CLIENT_INPUT_PROTOCOL:" << endl 
+               << "      g_value_set_object (value, client->input_protocol);" << endl 
+               << "      break;" << endl << "    case PROP_" << this->nspace_uc << service_name_uc 
+               << "_CLIENT_OUTPUT_PROTOCOL:" << endl 
+               << "      g_value_set_object (value, client->output_protocol);" << endl 
+               << "      break;" << endl << "  }" << endl << "}" << endl << endl; 
+  } 
+ 
+  // Generate client method implementations 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    string name = (*f_iter)->get_name(); 
+    string funname = initial_caps_to_underscores(name); 
+ 
+    // Get the struct of function call params and exceptions 
+    t_struct* arg_struct = (*f_iter)->get_arglist(); 
+ 
+    // Function for sending 
+    t_function send_function(g_type_void, 
+                             service_name_lc + string("_client_send_") + funname, 
+                             (*f_iter)->get_arglist()); 
+ 
+    // Open the send function 
+    indent(f_service_) << function_signature(&send_function) << endl; 
+    scope_up(f_service_); 
+ 
+    string reqType = (*f_iter)->is_oneway() ? "T_ONEWAY" : "T_CALL"; 
+ 
+    // Serialize the request 
+    f_service_ << indent() << "gint32 cseqid = 0;" << endl << indent() 
+               << "ThriftProtocol * protocol = " << this->nspace_uc << base_service_name_uc 
+               << "_CLIENT (iface)->output_protocol;" << endl << endl << indent() 
+               << "if (thrift_protocol_write_message_begin (protocol, \"" << name << "\", " 
+               << reqType << ", cseqid, error) < 0)" << endl << indent() << "  return FALSE;" 
+               << endl << endl; 
+ 
+    generate_struct_writer(f_service_, arg_struct, "", "", false); 
+ 
+    f_service_ << indent() << "if (thrift_protocol_write_message_end (protocol, error) < 0)" << endl 
+               << indent() << "  return FALSE;" << endl << indent() 
+               << "if (!thrift_transport_flush (protocol->transport, error))" << endl << indent() 
+               << "  return FALSE;" << endl << indent() 
+               << "if (!thrift_transport_write_end (protocol->transport, error))" << endl 
+               << indent() << "  return FALSE;" << endl << endl << indent() << "return TRUE;" 
+               << endl; 
+ 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+ 
+    // Generate recv function only if not an async function 
+    if (!(*f_iter)->is_oneway()) { 
+      t_struct noargs(program_); 
+      t_function recv_function((*f_iter)->get_returntype(), 
+                               service_name_lc + string("_client_recv_") + funname, 
+                               &noargs, 
+                               (*f_iter)->get_xceptions()); 
+      // Open function 
+      indent(f_service_) << function_signature(&recv_function) << endl; 
+      scope_up(f_service_); 
+ 
+      f_service_ << indent() << "gint32 rseqid;" << endl 
+                 << indent() << "gchar * fname = NULL;" << endl 
+                 << indent() << "ThriftMessageType mtype;" << endl 
+                 << indent() << "ThriftProtocol * protocol = " 
+                 << this->nspace_uc << base_service_name_uc 
+                 << "_CLIENT (iface)->input_protocol;" << endl 
+                 << indent() << "ThriftApplicationException *xception;" << endl 
+                 << endl 
+                 << indent() << "if (thrift_protocol_read_message_begin " 
+                    "(protocol, &fname, &mtype, &rseqid, error) < 0) {" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "if (fname) g_free (fname);" << endl 
+                 << indent() << "return FALSE;" << endl; 
+      indent_down(); 
+      f_service_ << indent() << "}" << endl 
+                 << endl 
+                 << indent() << "if (mtype == T_EXCEPTION) {" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "if (fname) g_free (fname);" << endl 
+                 << indent() << "xception = g_object_new " 
+                    "(THRIFT_TYPE_APPLICATION_EXCEPTION, NULL);" << endl 
+                 << indent() << "thrift_struct_read (THRIFT_STRUCT (xception), " 
+                    "protocol, NULL);" << endl 
+                 << indent() << "thrift_protocol_read_message_end " 
+                    "(protocol, NULL);" << endl 
+                 << indent() << "thrift_transport_read_end " 
+                    "(protocol->transport, NULL);" << endl 
+                 << indent() << "g_set_error (error, " 
+                    "THRIFT_APPLICATION_EXCEPTION_ERROR,xception->type, " 
+                    "\"application error: %s\", xception->message);" << endl 
+                 << indent() << "g_object_unref (xception);" << endl 
+                 << indent() << "return FALSE;" << endl; 
+      indent_down(); 
+      f_service_ << indent() << "} else if (mtype != T_REPLY) {" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "if (fname) g_free (fname);" << endl 
+                 << indent() << "thrift_protocol_skip (protocol, T_STRUCT, " 
+                    "NULL);" << endl 
+                 << indent() << "thrift_protocol_read_message_end (protocol, " 
+                    "NULL);" << endl 
+                 << indent() << "thrift_transport_read_end (" 
+                    "protocol->transport, NULL);" << endl 
+                 << indent() << "g_set_error (error, " 
+                    "THRIFT_APPLICATION_EXCEPTION_ERROR, " 
+                    "THRIFT_APPLICATION_EXCEPTION_ERROR_INVALID_MESSAGE_TYPE, " 
+                    "\"invalid message type %d, expected T_REPLY\", mtype);" 
+                 << endl 
+                 << indent() << "return FALSE;" << endl; 
+      indent_down(); 
+      f_service_ << indent() << "} else if (strncmp (fname, \"" << name 
+                 << "\", " << name.length() << ") != 0) {" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "thrift_protocol_skip (protocol, T_STRUCT, " 
+                    "NULL);" << endl 
+                 << indent() << "thrift_protocol_read_message_end (protocol," 
+                    "error);" << endl 
+                 << indent() << "thrift_transport_read_end (" 
+                    "protocol->transport, error);" << endl 
+                 << indent() << "g_set_error (error, " 
+                    "THRIFT_APPLICATION_EXCEPTION_ERROR, " 
+                    "THRIFT_APPLICATION_EXCEPTION_ERROR_WRONG_METHOD_NAME, " 
+                    "\"wrong method name %s, expected " << name 
+                    << "\", fname);" << endl 
+                 << indent() << "if (fname) g_free (fname);" << endl 
+                 << indent() << "return FALSE;" << endl; 
+      indent_down(); 
+      f_service_ << indent() << "}" << endl 
+                 << indent() << "if (fname) g_free (fname);" << endl 
+                 << endl; 
+ 
+      t_struct* xs = (*f_iter)->get_xceptions(); 
+      const std::vector<t_field*>& xceptions = xs->get_members(); 
+      vector<t_field*>::const_iterator x_iter; 
+ 
+      { 
+        t_struct result(program_, tservice->get_name() + "_" + (*f_iter)->get_name() + "_result"); 
+        t_field success((*f_iter)->get_returntype(), "*_return", 0); 
+        if (!(*f_iter)->get_returntype()->is_void()) { 
+          result.append(&success); 
+        } 
+ 
+        // add readers for exceptions, dereferencing the pointer. 
+        for (x_iter = xceptions.begin(); x_iter != xceptions.end(); x_iter++) { 
+          t_field* xception = new t_field((*x_iter)->get_type(), 
+                                          "*" + (*x_iter)->get_name(), 
+                                          (*x_iter)->get_key()); 
+          result.append(xception); 
+        } 
+ 
+        generate_struct_reader(f_service_, &result, "", "", false); 
+      } 
+ 
+      f_service_ << indent() << "if (thrift_protocol_read_message_end (protocol, error) < 0)" 
+                 << endl << indent() << "  return FALSE;" << endl << endl << indent() 
+                 << "if (!thrift_transport_read_end (protocol->transport, error))" << endl 
+                 << indent() << "  return FALSE;" << endl << endl; 
+ 
+      // copy over any throw exceptions and return failure 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); x_iter++) { 
+        f_service_ << indent() << "if (*" << (*x_iter)->get_name() << " != NULL)" << endl 
+                   << indent() << "{" << endl << indent() << "    g_set_error (error, " 
+                   << this->nspace_uc 
+                   << to_upper_case(initial_caps_to_underscores((*x_iter)->get_type()->get_name())) 
+                   << "_ERROR, " << this->nspace_uc 
+                   << to_upper_case(initial_caps_to_underscores((*x_iter)->get_type()->get_name())) 
+                   << "_ERROR_CODE, \"" << (*x_iter)->get_type()->get_name() << "\");" << endl 
+                   << indent() << "    return FALSE;" << endl << indent() << "}" << endl; 
+      } 
+      // Close function 
+      indent(f_service_) << "return TRUE;" << endl; 
+      scope_down(f_service_); 
+      f_service_ << endl; 
+    } 
+ 
+    // Open function 
+    t_function service_function((*f_iter)->get_returntype(), 
+                                service_name_lc + string("_client_") + funname, 
+                                (*f_iter)->get_arglist(), 
+                                (*f_iter)->get_xceptions()); 
+    indent(f_service_) << function_signature(&service_function) << endl; 
+    scope_up(f_service_); 
+ 
+    // wrap each function 
+    f_service_ << indent() << "if (!" << this->nspace_lc << service_name_lc << "_client_send_" 
+               << funname << " (iface"; 
+ 
+    // Declare the function arguments 
+    const vector<t_field*>& fields = arg_struct->get_members(); 
+    vector<t_field*>::const_iterator fld_iter; 
+    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+      f_service_ << ", " << (*fld_iter)->get_name(); 
+    } 
+    f_service_ << ", error))" << endl << indent() << "  return FALSE;" << endl; 
+ 
+    // if not oneway, implement recv 
+    if (!(*f_iter)->is_oneway()) { 
+      string ret = (*f_iter)->get_returntype()->is_void() ? "" : "_return, "; 
+ 
+      const vector<t_field*>& xceptions = (*f_iter)->get_xceptions()->get_members(); 
+      vector<t_field*>::const_iterator x_iter; 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+        ret += (*x_iter)->get_name(); 
+        ret += ", "; 
+      } 
+ 
+      f_service_ << indent() << "if (!" << this->nspace_lc << service_name_lc << "_client_recv_" 
+                 << funname << " (iface, " << ret << "error))" << endl << indent() 
+                 << "  return FALSE;" << endl; 
+    } 
+ 
+    // return TRUE which means all functions were called OK 
+    indent(f_service_) << "return TRUE;" << endl; 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+  } 
+ 
+  // create the interface initializer 
+  f_service_ << "static void" << endl 
+             << this->nspace_lc << service_name_lc << "_if_interface_init (" 
+             << this->nspace << service_name_ << "IfInterface *iface)" << endl; 
+  scope_up(f_service_); 
+  if (functions.size() > 0) { 
+    for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+      /* make the function name C friendly */ 
+      string funname = initial_caps_to_underscores((*f_iter)->get_name()); 
+ 
+      f_service_ << indent() << "iface->" << funname << " = " << this->nspace_lc 
+                 << service_name_lc << "_client_" << funname << ";" << endl; 
+    } 
+  } 
+  else { 
+    f_service_ << indent() << "THRIFT_UNUSED_VAR (iface);" << endl; 
+  } 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // create the client instance initializer 
+  f_service_ << "static void" << endl 
+             << this->nspace_lc << service_name_lc << "_client_init (" 
+             << this->nspace << service_name_ << "Client *client)" << endl; 
+  scope_up(f_service_); 
+  if (!extends_service) { 
+    f_service_ << indent() << "client->input_protocol = NULL;" << endl 
+               << indent() << "client->output_protocol = NULL;" << endl; 
+  } 
+  else { 
+    f_service_ << indent() << "THRIFT_UNUSED_VAR (client);" << endl; 
+  } 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // create the client class initializer 
+  f_service_ << "static void" << endl << this->nspace_lc << service_name_lc 
+             << "_client_class_init (" << this->nspace << service_name_ << "ClientClass *cls)" 
+             << endl << "{" << endl; 
+  if (!extends_service) { 
+    f_service_ << "  GObjectClass *gobject_class = G_OBJECT_CLASS (cls);" << endl 
+               << "  GParamSpec *param_spec;" << endl << endl 
+               << "  gobject_class->set_property = " << this->nspace_lc << service_name_lc 
+               << "_client_set_property;" << endl 
+               << "  gobject_class->get_property = " << this->nspace_lc << service_name_lc 
+               << "_client_get_property;" << endl << endl 
+               << "  param_spec = g_param_spec_object (\"input_protocol\"," << endl 
+               << "                                    \"input protocol (construct)\"," << endl 
+               << "                                    \"Set the client input protocol\"," << endl 
+               << "                                    THRIFT_TYPE_PROTOCOL," << endl 
+               << "                                    G_PARAM_READWRITE);" << endl 
+               << "  g_object_class_install_property (gobject_class," << endl 
+               << "                                   PROP_" << this->nspace_uc << service_name_uc 
+               << "_CLIENT_INPUT_PROTOCOL, param_spec);" << endl << endl 
+               << "  param_spec = g_param_spec_object (\"output_protocol\"," << endl 
+               << "                                    \"output protocol (construct)\"," << endl 
+               << "                                    \"Set the client output protocol\"," << endl 
+               << "                                    THRIFT_TYPE_PROTOCOL," << endl 
+               << "                                    G_PARAM_READWRITE);" << endl 
+               << "  g_object_class_install_property (gobject_class," << endl 
+               << "                                   PROP_" << this->nspace_uc << service_name_uc 
+               << "_CLIENT_OUTPUT_PROTOCOL, param_spec);" << endl; 
+  } 
+  else { 
+    f_service_ << "  THRIFT_UNUSED_VAR (cls);" << endl; 
+  } 
+  f_service_ << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates C code that represents a Thrift service handler. 
+ * 
+ * @param tservice The service for which to generate a handler. 
+ */ 
+void t_c_glib_generator::generate_service_handler(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator function_iter; 
+ 
+  string service_name_lc = to_lower_case(initial_caps_to_underscores(service_name_)); 
+  string service_name_uc = to_upper_case(service_name_lc); 
+ 
+  string class_name = this->nspace + service_name_ + "Handler"; 
+  string class_name_lc = to_lower_case(initial_caps_to_underscores(class_name)); 
+  string class_name_uc = to_upper_case(class_name_lc); 
+ 
+  string parent_class_name; 
+  string parent_type_name; 
+ 
+  string args_indent; 
+ 
+  // The service this service extends, or NULL if it extends no service 
+  t_service* extends_service = tservice->get_extends(); 
+ 
+  // Determine the name of our parent service (if any) and the handler class' 
+  // parent class name and type 
+  if (extends_service) { 
+    string parent_service_name = extends_service->get_name(); 
+    string parent_service_name_lc = to_lower_case(initial_caps_to_underscores(parent_service_name)); 
+    string parent_service_name_uc = to_upper_case(parent_service_name_lc); 
+ 
+    parent_class_name = this->nspace + parent_service_name + "Handler"; 
+    parent_type_name = this->nspace_uc + "TYPE_" + parent_service_name_uc + "_HANDLER"; 
+  } else { 
+    parent_class_name = "GObject"; 
+    parent_type_name = "G_TYPE_OBJECT"; 
+  } 
+ 
+  // Generate the handler class' definition in the header file 
+ 
+  // Generate the handler instance definition 
+  f_header_ << "/* " << service_name_ << " handler (abstract base class) */" << endl << "struct _" 
+            << class_name << endl << "{" << endl; 
+  indent_up(); 
+  f_header_ << indent() << parent_class_name << " parent;" << endl; 
+  indent_down(); 
+  f_header_ << "};" << endl << "typedef struct _" << class_name << " " << class_name << ";" << endl 
+            << endl; 
+ 
+  // Generate the handler class definition, including its class members 
+  // (methods) 
+  f_header_ << "struct _" << class_name << "Class" << endl << "{" << endl; 
+  indent_up(); 
+  f_header_ << indent() << parent_class_name << "Class parent;" << endl << endl; 
+ 
+  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) { 
+    string method_name = initial_caps_to_underscores((*function_iter)->get_name()); 
+    t_type* return_type = (*function_iter)->get_returntype(); 
+    t_struct* arg_list = (*function_iter)->get_arglist(); 
+    t_struct* x_list = (*function_iter)->get_xceptions(); 
+    bool has_return = !return_type->is_void(); 
+    bool has_args = arg_list->get_members().size() == 0; 
+    bool has_xceptions = x_list->get_members().size() == 0; 
+ 
+    string params = "(" + this->nspace + service_name_ + "If *iface" 
+                    + (has_return ? ", " + type_name(return_type) + "* _return" : "") 
+                    + (has_args ? "" : (", " + argument_list(arg_list))) 
+                    + (has_xceptions ? "" : (", " + xception_list(x_list))) + ", GError **error)"; 
+ 
+    indent(f_header_) << "gboolean (*" << method_name << ") " << params << ";" << endl; 
+  } 
+  indent_down(); 
+ 
+  f_header_ << "};" << endl << "typedef struct _" << class_name << "Class " << class_name 
+            << "Class;" << endl << endl; 
+ 
+  // Generate the remaining header boilerplate 
+  f_header_ << "GType " << class_name_lc << "_get_type (void);" << endl << "#define " 
+            << this->nspace_uc << "TYPE_" << service_name_uc << "_HANDLER " 
+            << "(" << class_name_lc << "_get_type())" << endl << "#define " << class_name_uc 
+            << "(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_HANDLER, " << class_name << "))" << endl << "#define " 
+            << this->nspace_uc << "IS_" << service_name_uc << "_HANDLER(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_HANDLER))" << endl << "#define " << class_name_uc 
+            << "_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_HANDLER, " << class_name << "Class))" << endl << "#define " 
+            << this->nspace_uc << "IS_" << service_name_uc << "_HANDLER_CLASS(c) " 
+            << "(G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc << "TYPE_" << service_name_uc 
+            << "_HANDLER))" << endl << "#define " << this->nspace_uc << service_name_uc 
+            << "_HANDLER_GET_CLASS(obj) " 
+            << "(G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_HANDLER, " << class_name << "Class))" << endl << endl; 
+ 
+  // Generate the handler class' method definitions 
+  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) { 
+    string method_name = initial_caps_to_underscores((*function_iter)->get_name()); 
+    t_type* return_type = (*function_iter)->get_returntype(); 
+    t_struct* arg_list = (*function_iter)->get_arglist(); 
+    t_struct* x_list = (*function_iter)->get_xceptions(); 
+    bool has_return = !return_type->is_void(); 
+    bool has_args = arg_list->get_members().size() == 0; 
+    bool has_xceptions = x_list->get_members().size() == 0; 
+ 
+    string params = "(" + this->nspace + service_name_ + "If *iface" 
+                    + (has_return ? ", " + type_name(return_type) + "* _return" : "") 
+                    + (has_args ? "" : (", " + argument_list(arg_list))) 
+                    + (has_xceptions ? "" : (", " + xception_list(x_list))) + ", GError **error)"; 
+ 
+    f_header_ << "gboolean " << class_name_lc << "_" << method_name << " " << params << ";" << endl; 
+  } 
+  f_header_ << endl; 
+ 
+  // Generate the handler's implementation in the implementation file 
+ 
+  // Generate the implementation boilerplate 
+  f_service_ << "static void" << endl << class_name_lc << "_" << service_name_lc 
+             << "_if_interface_init (" << this->nspace << service_name_ << "IfInterface *iface);" 
+             << endl << endl; 
+ 
+  args_indent = string(25, ' '); 
+  f_service_ << "G_DEFINE_TYPE_WITH_CODE (" << class_name << ", " << endl << args_indent 
+             << class_name_lc << "," << endl << args_indent << parent_type_name << "," << endl 
+             << args_indent << "G_IMPLEMENT_INTERFACE (" << this->nspace_uc << "TYPE_" 
+             << service_name_uc << "_IF," << endl; 
+  args_indent += string(23, ' '); 
+  f_service_ << args_indent << class_name_lc << "_" << service_name_lc << "_if_interface_init))" 
+             << endl << endl; 
+ 
+  // Generate the handler method implementations 
+  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) { 
+    string function_name = (*function_iter)->get_name(); 
+    string method_name = initial_caps_to_underscores(function_name); 
+    t_type* return_type = (*function_iter)->get_returntype(); 
+    t_struct* arg_list = (*function_iter)->get_arglist(); 
+    t_struct* x_list = (*function_iter)->get_xceptions(); 
+ 
+    const vector<t_field*>& args = arg_list->get_members(); 
+    const vector<t_field*>& xceptions = x_list->get_members(); 
+ 
+    vector<t_field*>::const_iterator field_iter; 
+ 
+    t_function implementing_function(return_type, 
+                                     service_name_lc + "_handler_" + method_name, 
+                                     arg_list, 
+                                     x_list, 
+                                     (*function_iter)->is_oneway()); 
+ 
+    indent(f_service_) << function_signature(&implementing_function) << endl; 
+    scope_up(f_service_); 
+    f_service_ << indent() << "g_return_val_if_fail (" << this->nspace_uc << "IS_" 
+               << service_name_uc << "_HANDLER (iface), FALSE);" << endl << endl << indent() 
+               << "return " << class_name_uc << "_GET_CLASS (iface)" 
+               << "->" << method_name << " (iface, "; 
+ 
+    if (!return_type->is_void()) { 
+      f_service_ << "_return, "; 
+    } 
+    for (field_iter = args.begin(); field_iter != args.end(); ++field_iter) { 
+      f_service_ << (*field_iter)->get_name() << ", "; 
+    } 
+    for (field_iter = xceptions.begin(); field_iter != xceptions.end(); ++field_iter) { 
+      f_service_ << (*field_iter)->get_name() << ", "; 
+    } 
+    f_service_ << "error);" << endl; 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+  } 
+ 
+  // Generate the handler interface initializer 
+  f_service_ << "static void" << endl << class_name_lc << "_" << service_name_lc 
+             << "_if_interface_init (" << this->nspace << service_name_ << "IfInterface *iface)" 
+             << endl; 
+  scope_up(f_service_); 
+  if (functions.size() > 0) { 
+    for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) { 
+      string method_name = initial_caps_to_underscores((*function_iter)->get_name()); 
+ 
+      f_service_ << indent() << "iface->" << method_name << " = " << class_name_lc << "_" 
+                 << method_name << ";" << endl; 
+    } 
+  } 
+  else { 
+    f_service_ << "THRIFT_UNUSED_VAR (iface);" << endl; 
+  } 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate the handler instance initializer 
+  f_service_ << "static void" << endl << class_name_lc << "_init (" << class_name << " *self)" 
+             << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "THRIFT_UNUSED_VAR (self);" << endl; 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate the handler class initializer 
+  f_service_ << "static void" << endl 
+             << class_name_lc << "_class_init (" << class_name << "Class *cls)" 
+             << endl; 
+  scope_up(f_service_); 
+  if (functions.size() > 0) { 
+    for (function_iter = functions.begin(); 
+         function_iter != functions.end(); 
+         ++function_iter) { 
+      string function_name = (*function_iter)->get_name(); 
+      string method_name = initial_caps_to_underscores(function_name); 
+ 
+      // All methods are pure virtual and must be implemented by subclasses 
+      f_service_ << indent() << "cls->" << method_name << " = NULL;" << endl; 
+    } 
+  } 
+  else { 
+    f_service_ << indent() << "THRIFT_UNUSED_VAR (cls);" << endl; 
+  } 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+} 
+ 
+/** 
+ * Generates C code that represents a Thrift service processor. 
+ * 
+ * @param tservice The service for which to generate a processor 
+ */ 
+void t_c_glib_generator::generate_service_processor(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator function_iter; 
+ 
+  string service_name_lc = to_lower_case(initial_caps_to_underscores(service_name_)); 
+  string service_name_uc = to_upper_case(service_name_lc); 
+ 
+  string class_name = this->nspace + service_name_ + "Processor"; 
+  string class_name_lc = to_lower_case(initial_caps_to_underscores(class_name)); 
+  string class_name_uc = to_upper_case(class_name_lc); 
+ 
+  string parent_class_name; 
+  string parent_type_name; 
+ 
+  string handler_class_name = this->nspace + service_name_ + "Handler"; 
+  string handler_class_name_lc = initial_caps_to_underscores(handler_class_name); 
+ 
+  string process_function_type_name = class_name + "ProcessFunction"; 
+  string process_function_def_type_name = 
+    class_name_lc + "_process_function_def"; 
+ 
+  string function_name; 
+  string args_indent; 
+ 
+  // The service this service extends, or NULL if it extends no service 
+  t_service* extends_service = tservice->get_extends(); 
+ 
+  // Determine the name of our parent service (if any) and the 
+  // processor class' parent class name and type 
+  if (extends_service) { 
+    string parent_service_name = extends_service->get_name(); 
+    string parent_service_name_lc = to_lower_case(initial_caps_to_underscores(parent_service_name)); 
+    string parent_service_name_uc = to_upper_case(parent_service_name_lc); 
+ 
+    parent_class_name = this->nspace + parent_service_name + "Processor"; 
+    parent_type_name = this->nspace_uc + "TYPE_" + parent_service_name_uc + "_PROCESSOR"; 
+  } else { 
+    parent_class_name = "ThriftDispatchProcessor"; 
+    parent_type_name = "THRIFT_TYPE_DISPATCH_PROCESSOR"; 
+  } 
+ 
+  // Generate the processor class' definition in the header file 
+ 
+  // Generate the processor instance definition 
+  f_header_ << "/* " << service_name_ << " processor */" << endl << "struct _" << class_name << endl 
+            << "{" << endl; 
+  indent_up(); 
+  f_header_ << indent() << parent_class_name << " parent;" << endl << endl << indent() 
+            << "/* protected */" << endl << indent() 
+            << this->nspace + service_name_ + "Handler *handler;" << endl << indent() 
+            << "GHashTable *process_map;" << endl; 
+  indent_down(); 
+  f_header_ << "};" << endl << "typedef struct _" << class_name << " " << class_name << ";" << endl 
+            << endl; 
+ 
+  // Generate the processor class definition 
+  f_header_ << "struct _" << class_name << "Class" << endl << "{" << endl; 
+  indent_up(); 
+  f_header_ << indent() << parent_class_name << "Class parent;" << endl << endl << indent() 
+            << "/* protected */" << endl << indent() 
+            << "gboolean (*dispatch_call) (ThriftDispatchProcessor *processor," << endl; 
+  args_indent = indent() + string(27, ' '); 
+  f_header_ << args_indent << "ThriftProtocol *in," << endl << args_indent << "ThriftProtocol *out," 
+            << endl << args_indent << "gchar *fname," << endl << args_indent << "gint32 seqid," 
+            << endl << args_indent << "GError **error);" << endl; 
+  indent_down(); 
+  f_header_ << "};" << endl << "typedef struct _" << class_name << "Class " << class_name 
+            << "Class;" << endl << endl; 
+ 
+  // Generate the remaining header boilerplate 
+  f_header_ << "GType " << class_name_lc << "_get_type (void);" << endl << "#define " 
+            << this->nspace_uc << "TYPE_" << service_name_uc << "_PROCESSOR " 
+            << "(" << class_name_lc << "_get_type())" << endl << "#define " << class_name_uc 
+            << "(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_PROCESSOR, " << class_name << "))" << endl << "#define " 
+            << this->nspace_uc << "IS_" << service_name_uc << "_PROCESSOR(obj) " 
+            << "(G_TYPE_CHECK_INSTANCE_TYPE ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_PROCESSOR))" << endl << "#define " << class_name_uc 
+            << "_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_PROCESSOR, " << class_name << "Class))" << endl << "#define " 
+            << this->nspace_uc << "IS_" << service_name_uc << "_PROCESSOR_CLASS(c) " 
+            << "(G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc << "TYPE_" << service_name_uc 
+            << "_PROCESSOR))" << endl << "#define " << this->nspace_uc << service_name_uc 
+            << "_PROCESSOR_GET_CLASS(obj) " 
+            << "(G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_" 
+            << service_name_uc << "_PROCESSOR, " << class_name << "Class))" << endl << endl; 
+ 
+  // Generate the processor's implementation in the implementation file 
+ 
+  // Generate the processor's properties enum 
+  f_service_ << "enum _" << class_name << "Properties" << endl << "{" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "PROP_" << class_name_uc << "_0," << endl << indent() << "PROP_" 
+             << class_name_uc << "_HANDLER" << endl; 
+  indent_down(); 
+  f_service_ << "};" << endl << endl; 
+ 
+  // Generate the implementation boilerplate 
+  args_indent = string(15, ' '); 
+  f_service_ << "G_DEFINE_TYPE (" << class_name << "," << endl << args_indent << class_name_lc 
+             << "," << endl << args_indent << parent_type_name << ")" << endl << endl; 
+ 
+  // Generate the processor's processing-function type 
+  args_indent = string(process_function_type_name.length() + 23, ' '); 
+  f_service_ << "typedef gboolean (* " << process_function_type_name << ") (" 
+             << class_name << " *, " << endl 
+             << args_indent << "gint32," << endl 
+             << args_indent << "ThriftProtocol *," << endl 
+             << args_indent << "ThriftProtocol *," << endl 
+             << args_indent << "GError **);" << endl 
+             << endl; 
+ 
+  // Generate the processor's processing-function-definition type 
+  f_service_ << "typedef struct" << endl 
+             << "{" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "gchar *name;" << endl 
+             << indent() << process_function_type_name << " function;" << endl; 
+  indent_down(); 
+  f_service_ << "} " << process_function_def_type_name << ";" << endl 
+             << endl; 
+ 
+  // Generate forward declarations of the processor's processing functions so we 
+  // can refer to them in the processing-function-definition struct below and 
+  // keep all of the processor's declarations in one place 
+  for (function_iter = functions.begin(); 
+       function_iter != functions.end(); 
+       ++function_iter) { 
+    function_name = class_name_lc + "_process_" 
+      + initial_caps_to_underscores((*function_iter)->get_name()); 
+ 
+    args_indent = string(function_name.length() + 2, ' '); 
+    f_service_ << "static gboolean" << endl 
+               << function_name << " (" 
+               << class_name << " *," << endl 
+               << args_indent << "gint32," << endl 
+               << args_indent << "ThriftProtocol *," << endl 
+               << args_indent << "ThriftProtocol *," << endl 
+               << args_indent << "GError **);" << endl; 
+  } 
+  f_service_ << endl; 
+ 
+  // Generate the processor's processing-function definitions, if the service 
+  // defines any methods 
+  if (functions.size() > 0) { 
+    f_service_ << indent() << "static " << process_function_def_type_name 
+               << endl 
+               << indent() << class_name_lc << "_process_function_defs[" 
+               << functions.size() << "] = {" << endl; 
+    indent_up(); 
+    for (function_iter = functions.begin(); 
+         function_iter != functions.end(); 
+         ++function_iter) { 
+      string service_function_name = (*function_iter)->get_name(); 
+      string process_function_name = class_name_lc + "_process_" 
+        + initial_caps_to_underscores(service_function_name); 
+ 
+      f_service_ << indent() << "{" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "\"" << service_function_name << "\"," << endl 
+                 << indent() << process_function_name << endl; 
+      indent_down(); 
+      f_service_ << indent() << "}" 
+                 << (function_iter == --functions.end() ? "" : ",") << endl; 
+    } 
+    indent_down(); 
+    f_service_ << indent() << "};" << endl 
+               << endl; 
+  } 
+ 
+  // Generate the processor's processing functions 
+  for (function_iter = functions.begin(); function_iter != functions.end(); ++function_iter) { 
+    string service_function_name = (*function_iter)->get_name(); 
+    string service_function_name_ic = underscores_to_initial_caps(service_function_name); 
+    string service_function_name_lc = initial_caps_to_underscores(service_function_name); 
+    string service_function_name_uc = to_upper_case(service_function_name_lc); 
+ 
+    t_type* return_type = (*function_iter)->get_returntype(); 
+    bool has_return_value = !return_type->is_void(); 
+ 
+    t_struct* arg_list = (*function_iter)->get_arglist(); 
+    const vector<t_field*>& args = arg_list->get_members(); 
+    vector<t_field*>::const_iterator arg_iter; 
+ 
+    const vector<t_field*>& xceptions = (*function_iter)->get_xceptions()->get_members(); 
+    vector<t_field*>::const_iterator xception_iter; 
+ 
+    string args_class_name = this->nspace + service_name_ + service_function_name_ic + "Args"; 
+    string args_class_type = this->nspace_uc + "TYPE_" + service_name_uc + "_" 
+                             + service_function_name_uc + "_ARGS"; 
+ 
+    string result_class_name = this->nspace + service_name_ + service_function_name_ic + "Result"; 
+    string result_class_type = this->nspace_uc + "TYPE_" + service_name_uc + "_" 
+                               + service_function_name_uc + "_RESULT"; 
+ 
+    string handler_function_name = handler_class_name_lc + "_" + service_function_name_lc; 
+ 
+    function_name = class_name_lc + "_process_" 
+                    + initial_caps_to_underscores(service_function_name); 
+ 
+    args_indent = string(function_name.length() + 2, ' '); 
+    f_service_ << "static gboolean" << endl << function_name << " (" << class_name << " *self," 
+               << endl << args_indent << "gint32 sequence_id," << endl << args_indent 
+               << "ThriftProtocol *input_protocol," << endl << args_indent 
+               << "ThriftProtocol *output_protocol," << endl << args_indent << "GError **error)" 
+               << endl; 
+    scope_up(f_service_); 
+    f_service_ << indent() << "gboolean result = TRUE;" << endl 
+               << indent() << "ThriftTransport * transport;" << endl 
+               << indent() << "ThriftApplicationException *xception;" << endl 
+               << indent() << args_class_name + " * args =" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "g_object_new (" << args_class_type << ", NULL);" << endl << endl; 
+    indent_down(); 
+    if ((*function_iter)->is_oneway()) { 
+      f_service_ << indent() << "THRIFT_UNUSED_VAR (sequence_id);" << endl << indent() 
+                 << "THRIFT_UNUSED_VAR (output_protocol);" << endl << endl; 
+    } 
+    f_service_ << indent() << "g_object_get (input_protocol, \"transport\", " 
+               << "&transport, NULL);" << endl << endl; 
+ 
+    // Read the method's arguments from the caller 
+    f_service_ << indent() << "if ((thrift_struct_read (THRIFT_STRUCT (args), " 
+               << "input_protocol, error) != -1) &&" << endl << indent() 
+               << "    (thrift_protocol_read_message_end (input_protocol, " 
+               << "error) != -1) &&" << endl << indent() 
+               << "    (thrift_transport_read_end (transport, error) != FALSE))" << endl; 
+    scope_up(f_service_); 
+ 
+    for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) { 
+      f_service_ << indent() << property_type_name((*arg_iter)->get_type()) << " " 
+                 << (*arg_iter)->get_name() << ";" << endl; 
+    } 
+    for (xception_iter = xceptions.begin(); xception_iter != xceptions.end(); ++xception_iter) { 
+      f_service_ << indent() << type_name((*xception_iter)->get_type()) << " " 
+                 << initial_caps_to_underscores((*xception_iter)->get_name()) << " = NULL;" << endl; 
+    } 
+    if (has_return_value) { 
+      f_service_ << indent() << property_type_name(return_type) << " return_value;" << endl; 
+    } 
+    if (!(*function_iter)->is_oneway()) { 
+      f_service_ << indent() << result_class_name << " * result_struct;" << endl; 
+    } 
+    f_service_ << endl; 
+ 
+    if (args.size() > 0) { 
+      f_service_ << indent() << "g_object_get (args," << endl; 
+      args_indent = indent() + string(14, ' '); 
+      for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) { 
+        string arg_name = (*arg_iter)->get_name(); 
+ 
+        f_service_ << args_indent << "\"" << arg_name << "\", &" << arg_name << "," << endl; 
+      } 
+      f_service_ << args_indent << "NULL);" << endl << endl; 
+    } 
+ 
+    if (!(*function_iter)->is_oneway()) { 
+      f_service_ << indent() << "g_object_unref (transport);" << endl << indent() 
+                 << "g_object_get (output_protocol, \"transport\", " 
+                 << "&transport, NULL);" << endl << endl << indent() 
+                 << "result_struct = g_object_new (" << result_class_type << ", NULL);" << endl; 
+      if (has_return_value) { 
+        f_service_ << indent() << "g_object_get (result_struct, " 
+                                  "\"success\", &return_value, NULL);" << endl; 
+      } 
+      f_service_ << endl; 
+    } 
+ 
+    // Pass the arguments to the corresponding method in the handler 
+    f_service_ << indent() << "if (" << handler_function_name << " (" << this->nspace_uc 
+               << service_name_uc << "_IF (self->handler)," << endl; 
+    args_indent = indent() + string(handler_function_name.length() + 6, ' '); 
+    if (has_return_value) { 
+      string return_type_name = type_name(return_type); 
+ 
+      f_service_ << args_indent; 
+ 
+      // Cast return_value if it was declared as a type other than the return 
+      // value's actual type---this is true for integer values 32 bits or fewer 
+      // in width, for which GLib requires a plain gint type be used when 
+      // storing or retrieving as an object property 
+      if (return_type_name != property_type_name(return_type)) { 
+        if (return_type_name[return_type_name.length() - 1] != '*') { 
+          return_type_name += ' '; 
+        } 
+        return_type_name += '*'; 
+ 
+        f_service_ << "(" << return_type_name << ")"; 
+      } 
+ 
+      f_service_ << "&return_value," << endl; 
+    } 
+    for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) { 
+      f_service_ << args_indent << (*arg_iter)->get_name() << "," << endl; 
+    } 
+    for (xception_iter = xceptions.begin(); xception_iter != xceptions.end(); ++xception_iter) { 
+      f_service_ << args_indent << "&" << initial_caps_to_underscores((*xception_iter)->get_name()) 
+                 << "," << endl; 
+    } 
+    f_service_ << args_indent << "error) == TRUE)" << endl; 
+    scope_up(f_service_); 
+ 
+    // The handler reported success; return the result, if any, to the caller 
+    if (!(*function_iter)->is_oneway()) { 
+      if (has_return_value) { 
+        f_service_ << indent() << "g_object_set (result_struct, \"success\", "; 
+        if (type_name(return_type) != property_type_name(return_type)) { 
+          // Roundtrip cast to fix the position of sign bit. 
+          f_service_ << "(" << property_type_name(return_type) << ")" 
+                     << "(" << type_name(return_type) << ")"; 
+        } 
+        f_service_ << "return_value, " 
+                   << "NULL);" << endl; 
+ 
+        // Deallocate (or unref) return_value 
+        return_type = get_true_type(return_type); 
+        if (return_type->is_base_type()) { 
+          t_base_type* base_type = ((t_base_type*)return_type); 
+ 
+          if (base_type->get_base() == t_base_type::TYPE_STRING) { 
+            f_service_ << indent() << "if (return_value != NULL)" << endl; 
+            indent_up(); 
+            if (base_type->is_binary()) { 
+              f_service_ << indent() << "g_byte_array_unref (return_value);" << endl; 
+            } else { 
+              f_service_ << indent() << "g_free (return_value);" << endl; 
+            } 
+            indent_down(); 
+          } 
+        } else if (return_type->is_container()) { 
+          f_service_ << indent() << "if (return_value != NULL)" << endl; 
+          indent_up(); 
+ 
+          if (return_type->is_list()) { 
+            t_type* elem_type = ((t_list*)return_type)->get_elem_type(); 
+ 
+            f_service_ << indent(); 
+            if (is_numeric(elem_type)) { 
+              f_service_ << "g_array_unref"; 
+            } else { 
+              f_service_ << "g_ptr_array_unref"; 
+            } 
+            f_service_ << " (return_value);" << endl; 
+          } else if (return_type->is_map() || return_type->is_set()) { 
+            f_service_ << indent() << "g_hash_table_unref (return_value);" << endl; 
+          } 
+ 
+          indent_down(); 
+        } else if (return_type->is_struct()) { 
+          f_service_ << indent() << "if (return_value != NULL)" << endl; 
+          indent_up(); 
+          f_service_ << indent() << "g_object_unref (return_value);" << endl; 
+          indent_down(); 
+        } 
+ 
+        f_service_ << endl; 
+      } 
+      f_service_ << indent() << "result =" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "((thrift_protocol_write_message_begin (output_protocol," << endl; 
+      args_indent = indent() + string(39, ' '); 
+      f_service_ << args_indent << "\"" << service_function_name << "\"," << endl << args_indent 
+                 << "T_REPLY," << endl << args_indent << "sequence_id," << endl << args_indent 
+                 << "error) != -1) &&" << endl << indent() 
+                 << " (thrift_struct_write (THRIFT_STRUCT (result_struct)," << endl; 
+      args_indent = indent() + string(23, ' '); 
+      f_service_ << args_indent << "output_protocol," << endl << args_indent << "error) != -1));" 
+                 << endl; 
+      indent_down(); 
+    } 
+    scope_down(f_service_); 
+    f_service_ << indent() << "else" << endl; 
+    scope_up(f_service_); 
+ 
+    // The handler reported failure; check to see if an application-defined 
+    // exception was raised and if so, return it to the caller 
+    f_service_ << indent(); 
+    if (xceptions.size() > 0) { 
+      for (xception_iter = xceptions.begin(); xception_iter != xceptions.end(); ++xception_iter) { 
+        f_service_ << "if (" << initial_caps_to_underscores((*xception_iter)->get_name()) 
+                   << " != NULL)" << endl; 
+        scope_up(f_service_); 
+        f_service_ << indent() << "g_object_set (result_struct," << endl; 
+        args_indent = indent() + string(14, ' '); 
+        f_service_ << args_indent << "\"" << (*xception_iter)->get_name() << "\", " 
+                   << (*xception_iter)->get_name() << "," << endl << args_indent << "NULL);" << endl 
+                   << endl; 
+        f_service_ << indent() << "result =" << endl; 
+        indent_up(); 
+        f_service_ << indent() << "((thrift_protocol_write_message_begin (output_protocol," << endl; 
+        args_indent = indent() + string(39, ' '); 
+        f_service_ << args_indent << "\"" << service_function_name << "\"," << endl << args_indent 
+                   << "T_REPLY," << endl << args_indent << "sequence_id," << endl << args_indent 
+                   << "error) != -1) &&" << endl << indent() 
+                   << " (thrift_struct_write (THRIFT_STRUCT (result_struct)," << endl; 
+        args_indent = indent() + string(23, ' '); 
+        f_service_ << args_indent << "output_protocol," << endl << args_indent << "error) != -1));" 
+                   << endl; 
+        indent_down(); 
+        scope_down(f_service_); 
+        f_service_ << indent() << "else" << endl; 
+      } 
+ 
+      scope_up(f_service_); 
+      f_service_ << indent(); 
+    } 
+ 
+    // If the handler reported failure but raised no application-defined 
+    // exception, return a Thrift application exception with the information 
+    // returned via GLib's own error-reporting mechanism 
+    f_service_ << "if (*error == NULL)" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "g_warning (\"" << service_name_ << "." 
+               << (*function_iter)->get_name() << " implementation returned FALSE \"" << endl 
+               << indent() << string(11, ' ') << "\"but did not set an error\");" << endl << endl; 
+    indent_down(); 
+    f_service_ << indent() << "xception =" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "g_object_new (THRIFT_TYPE_APPLICATION_EXCEPTION," << endl; 
+    args_indent = indent() + string(14, ' '); 
+    f_service_ << args_indent << "\"type\",    *error != NULL ? (*error)->code :" << endl 
+               << args_indent << string(11, ' ') << "THRIFT_APPLICATION_EXCEPTION_ERROR_UNKNOWN," 
+               << endl << args_indent << "\"message\", *error != NULL ? (*error)->message : NULL," 
+               << endl << args_indent << "NULL);" << endl; 
+    indent_down(); 
+    f_service_ << indent() << "g_clear_error (error);" << endl << endl << indent() 
+               << "result =" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "((thrift_protocol_write_message_begin (output_protocol," << endl; 
+    args_indent = indent() + string(39, ' '); 
+    f_service_ << args_indent << "\"" << service_function_name << "\"," << endl << args_indent 
+               << "T_EXCEPTION," << endl << args_indent << "sequence_id," << endl << args_indent 
+               << "error) != -1) &&" << endl << indent() 
+               << " (thrift_struct_write (THRIFT_STRUCT (xception)," << endl; 
+    args_indent = indent() + string(23, ' '); 
+    f_service_ << args_indent << "output_protocol," << endl << args_indent << "error) != -1));" 
+               << endl; 
+    indent_down(); 
+    f_service_ << endl << indent() << "g_object_unref (xception);" << endl; 
+ 
+    if (xceptions.size() > 0) { 
+      scope_down(f_service_); 
+    } 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+ 
+    // Dellocate or unref retrieved argument values as necessary 
+    for (arg_iter = args.begin(); arg_iter != args.end(); ++arg_iter) { 
+      string arg_name = (*arg_iter)->get_name(); 
+      t_type* arg_type = get_true_type((*arg_iter)->get_type()); 
+ 
+      if (arg_type->is_base_type()) { 
+        t_base_type* base_type = ((t_base_type*)arg_type); 
+ 
+        if (base_type->get_base() == t_base_type::TYPE_STRING) { 
+          f_service_ << indent() << "if (" << arg_name << " != NULL)" << endl; 
+          indent_up(); 
+          if (base_type->is_binary()) { 
+            f_service_ << indent() << "g_byte_array_unref (" << arg_name << ");" << endl; 
+          } else { 
+            f_service_ << indent() << "g_free (" << arg_name << ");" << endl; 
+          } 
+          indent_down(); 
+        } 
+      } else if (arg_type->is_container()) { 
+        f_service_ << indent() << "if (" << arg_name << " != NULL)" << endl; 
+        indent_up(); 
+ 
+        if (arg_type->is_list()) { 
+          t_type* elem_type = ((t_list*)arg_type)->get_elem_type(); 
+ 
+          f_service_ << indent(); 
+          if (is_numeric(elem_type)) { 
+            f_service_ << "g_array_unref"; 
+          } else { 
+            f_service_ << "g_ptr_array_unref"; 
+          } 
+          f_service_ << " (" << arg_name << ");" << endl; 
+        } else if (arg_type->is_map() || arg_type->is_set()) { 
+          f_service_ << indent() << "g_hash_table_unref (" << arg_name << ");" << endl; 
+        } 
+ 
+        indent_down(); 
+      } else if (arg_type->is_struct()) { 
+        f_service_ << indent() << "if (" << arg_name << " != NULL)" << endl; 
+        indent_up(); 
+        f_service_ << indent() << "g_object_unref (" << arg_name << ");" << endl; 
+        indent_down(); 
+      } 
+    } 
+ 
+    if (!(*function_iter)->is_oneway()) { 
+      f_service_ << indent() << "g_object_unref (result_struct);" << endl << endl << indent() 
+                 << "if (result == TRUE)" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "result =" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "((thrift_protocol_write_message_end " 
+                 << "(output_protocol, error) != -1) &&" << endl << indent() 
+                 << " (thrift_transport_write_end (transport, error) " 
+                 << "!= FALSE) &&" << endl << indent() 
+                 << " (thrift_transport_flush (transport, error) " 
+                 << "!= FALSE));" << endl; 
+      indent_down(); 
+      indent_down(); 
+    } 
+    scope_down(f_service_); 
+    f_service_ << indent() << "else" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "result = FALSE;" << endl; 
+    indent_down(); 
+ 
+    f_service_ << endl << indent() << "g_object_unref (transport);" << endl << indent() 
+               << "g_object_unref (args);" << endl << endl << indent() << "return result;" << endl; 
+    scope_down(f_service_); 
+ 
+    f_service_ << endl; 
+  } 
+ 
+  // Generate the processor's dispatch_call implementation 
+  function_name = class_name_lc + "_dispatch_call"; 
+  args_indent = indent() + string(function_name.length() + 2, ' '); 
+  f_service_ << "static gboolean" << endl << function_name 
+             << " (ThriftDispatchProcessor *dispatch_processor," << endl << args_indent 
+             << "ThriftProtocol *input_protocol," << endl << args_indent 
+             << "ThriftProtocol *output_protocol," << endl << args_indent << "gchar *method_name," 
+             << endl << args_indent << "gint32 sequence_id," << endl << args_indent 
+             << "GError **error)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << class_name_lc << "_process_function_def *" 
+             << "process_function_def;" << endl; 
+  f_service_ << indent() << "gboolean dispatch_result = FALSE;" << endl << endl << indent() 
+             << class_name << " *self = " << class_name_uc << " (dispatch_processor);" << endl; 
+  f_service_ << indent() << parent_class_name << "Class " 
+                                                 "*parent_class =" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "g_type_class_peek_parent (" << class_name_uc << "_GET_CLASS (self));" 
+             << endl; 
+  indent_down(); 
+  f_service_ << endl 
+             << indent() << "process_function_def = " 
+             << "g_hash_table_lookup (self->process_map, method_name);" << endl 
+             << indent() << "if (process_function_def != NULL)" << endl; 
+  scope_up(f_service_); 
+  args_indent = indent() + string(53, ' '); 
+  f_service_ << indent() << "g_free (method_name);" << endl 
+             << indent() << "dispatch_result = " 
+             << "(*process_function_def->function) (self," << endl 
+             << args_indent << "sequence_id," << endl 
+             << args_indent << "input_protocol," << endl 
+             << args_indent << "output_protocol," << endl 
+             << args_indent << "error);" << endl; 
+  scope_down(f_service_); 
+  f_service_ << indent() << "else" << endl; 
+  scope_up(f_service_); 
+ 
+  // Method name not recognized; chain up to our parent processor---note the 
+  // top-most implementation of this method, in ThriftDispatchProcessor itself, 
+  // will return an application exception to the caller if no class in the 
+  // hierarchy recognizes the method name 
+  f_service_ << indent() << "dispatch_result = parent_class->dispatch_call " 
+                            "(dispatch_processor," << endl; 
+  args_indent = indent() + string(47, ' '); 
+  f_service_ << args_indent << "input_protocol," << endl << args_indent << "output_protocol," 
+             << endl << args_indent << "method_name," << endl << args_indent << "sequence_id," 
+             << endl << args_indent << "error);" << endl; 
+  scope_down(f_service_); 
+  f_service_ << endl << indent() << "return dispatch_result;" << endl; 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate the processor's property setter 
+  function_name = class_name_lc + "_set_property"; 
+  args_indent = string(function_name.length() + 2, ' '); 
+  f_service_ << "static void" << endl << function_name << " (GObject *object," << endl 
+             << args_indent << "guint property_id," << endl << args_indent << "const GValue *value," 
+             << endl << args_indent << "GParamSpec *pspec)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl 
+             << endl << indent() << "switch (property_id)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "case PROP_" << class_name_uc << "_HANDLER:" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "if (self->handler != NULL)" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "g_object_unref (self->handler);" << endl; 
+  indent_down(); 
+  f_service_ << indent() << "self->handler = g_value_get_object (value);" << endl << indent() 
+             << "g_object_ref (self->handler);" << endl; 
+  if (extends_service) { 
+    // Chain up to set the handler in every superclass as well 
+    f_service_ << endl << indent() << "G_OBJECT_CLASS (" << class_name_lc << "_parent_class)->" 
+               << endl; 
+    indent_up(); 
+    f_service_ << indent() << "set_property (object, property_id, value, pspec);" << endl; 
+    indent_down(); 
+  } 
+  f_service_ << indent() << "break;" << endl; 
+  indent_down(); 
+  f_service_ << indent() << "default:" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);" 
+             << endl << indent() << "break;" << endl; 
+  indent_down(); 
+  scope_down(f_service_); 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate processor's property getter 
+  function_name = class_name_lc + "_get_property"; 
+  args_indent = string(function_name.length() + 2, ' '); 
+  f_service_ << "static void" << endl << function_name << " (GObject *object," << endl 
+             << args_indent << "guint property_id," << endl << args_indent << "GValue *value," 
+             << endl << args_indent << "GParamSpec *pspec)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl 
+             << endl << indent() << "switch (property_id)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "case PROP_" << class_name_uc << "_HANDLER:" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "g_value_set_object (value, self->handler);" << endl << indent() 
+             << "break;" << endl; 
+  indent_down(); 
+  f_service_ << indent() << "default:" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);" 
+             << endl << indent() << "break;" << endl; 
+  indent_down(); 
+  scope_down(f_service_); 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generator the processor's dispose function 
+  f_service_ << "static void" << endl << class_name_lc << "_dispose (GObject *gobject)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << class_name << " *self = " << class_name_uc << " (gobject);" << endl 
+             << endl << indent() << "if (self->handler != NULL)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "g_object_unref (self->handler);" << endl << indent() 
+             << "self->handler = NULL;" << endl; 
+  scope_down(f_service_); 
+  f_service_ << endl << indent() << "G_OBJECT_CLASS (" << class_name_lc << "_parent_class)" 
+                                                                           "->dispose (gobject);" 
+             << endl; 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate processor finalize function 
+  f_service_ << "static void" << endl << class_name_lc << "_finalize (GObject *gobject)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << this->nspace << service_name_ << "Processor *self = " << this->nspace_uc 
+             << service_name_uc << "_PROCESSOR (gobject);" << endl << endl << indent() 
+             << "thrift_safe_hash_table_destroy (self->process_map);" << endl << endl << indent() 
+             << "G_OBJECT_CLASS (" << class_name_lc << "_parent_class)" 
+                                                       "->finalize (gobject);" << endl; 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate processor instance initializer 
+  f_service_ << "static void" << endl << class_name_lc << "_init (" << class_name << " *self)" 
+             << endl; 
+  scope_up(f_service_); 
+  if (functions.size() > 0) { 
+    f_service_ << indent() << "guint index;" << endl 
+               << endl; 
+  } 
+  f_service_ << indent() << "self->handler = NULL;" << endl << indent() 
+             << "self->process_map = " 
+                "g_hash_table_new (g_str_hash, g_str_equal);" << endl; 
+  if (functions.size() > 0) { 
+    args_indent = string(21, ' '); 
+    f_service_ << endl 
+               << indent() << "for (index = 0; index < " 
+               << functions.size() << "; index += 1)" << endl; 
+    indent_up(); 
+    f_service_ << indent() << "g_hash_table_insert (self->process_map," << endl 
+               << indent() << args_indent 
+               << class_name_lc << "_process_function_defs[index].name," << endl 
+               << indent() << args_indent 
+               << "&" << class_name_lc << "_process_function_defs[index]" << ");" 
+               << endl; 
+    indent_down(); 
+  } 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  // Generate processor class initializer 
+  f_service_ << "static void" << endl << class_name_lc << "_class_init (" << class_name 
+             << "Class *cls)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "GObjectClass *gobject_class = G_OBJECT_CLASS (cls);" << endl 
+             << indent() << "ThriftDispatchProcessorClass *dispatch_processor_class =" << endl; 
+  indent_up(); 
+  f_service_ << indent() << "THRIFT_DISPATCH_PROCESSOR_CLASS (cls);" << endl; 
+  indent_down(); 
+  f_service_ << indent() << "GParamSpec *param_spec;" << endl << endl << indent() 
+             << "gobject_class->dispose = " << class_name_lc << "_dispose;" << endl << indent() 
+             << "gobject_class->finalize = " << class_name_lc << "_finalize;" << endl << indent() 
+             << "gobject_class->set_property = " << class_name_lc << "_set_property;" << endl 
+             << indent() << "gobject_class->get_property = " << class_name_lc << "_get_property;" 
+             << endl << endl << indent() 
+             << "dispatch_processor_class->dispatch_call = " << class_name_lc << "_dispatch_call;" 
+             << endl << indent() << "cls->dispatch_call = " << class_name_lc << "_dispatch_call;" 
+             << endl << endl << indent() << "param_spec = g_param_spec_object (\"handler\"," 
+             << endl; 
+  args_indent = indent() + string(34, ' '); 
+  f_service_ << args_indent << "\"Service handler implementation\"," << endl << args_indent 
+             << "\"The service handler implementation \"" << endl << args_indent 
+             << "\"to which method calls are dispatched.\"," << endl << args_indent 
+             << this->nspace_uc + "TYPE_" + service_name_uc + "_HANDLER," << endl << args_indent 
+             << "G_PARAM_READWRITE);" << endl; 
+  f_service_ << indent() << "g_object_class_install_property (gobject_class," << endl; 
+  args_indent = indent() + string(33, ' '); 
+  f_service_ << args_indent << "PROP_" << class_name_uc << "_HANDLER," << endl << args_indent 
+             << "param_spec);" << endl; 
+  scope_down(f_service_); 
+} 
+ 
+/** 
+ * Generates C code that represents a Thrift service server. 
+ */ 
+void t_c_glib_generator::generate_service_server(t_service* tservice) { 
+  (void)tservice; 
+  // Generate the service's handler class 
+  generate_service_handler(tservice); 
+ 
+  // Generate the service's processor class 
+  generate_service_processor(tservice); 
+} 
+ 
+/** 
+ * Generates C code to represent a THrift structure as a GObject. 
+ */ 
+void t_c_glib_generator::generate_object(t_struct* tstruct) { 
+  string name = tstruct->get_name(); 
+  string name_u = initial_caps_to_underscores(name); 
+  string name_uc = to_upper_case(name_u); 
+ 
+  string class_name = this->nspace + name; 
+  string class_name_lc = to_lower_case(initial_caps_to_underscores(class_name)); 
+  string class_name_uc = to_upper_case(class_name_lc); 
+ 
+  string function_name; 
+  string args_indent; 
+ 
+  // write the instance definition 
+  f_types_ << "struct _" << this->nspace << name << endl << "{ " << endl 
+           << "  ThriftStruct parent; " << endl << endl << "  /* public */" << endl; 
+ 
+  // for each field, add a member variable 
+  vector<t_field*>::const_iterator m_iter; 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = get_true_type((*m_iter)->get_type()); 
+    f_types_ << "  " << type_name(t) << " " << (*m_iter)->get_name() << ";" << endl; 
+    if ((*m_iter)->get_req() != t_field::T_REQUIRED) { 
+      f_types_ << "  gboolean __isset_" << (*m_iter)->get_name() << ";" << endl; 
+    } 
+  } 
+ 
+  // close the structure definition and create a typedef 
+  f_types_ << "};" << endl << "typedef struct _" << this->nspace << name << " " << this->nspace 
+           << name << ";" << endl << endl; 
+ 
+  // write the class definition 
+  f_types_ << "struct _" << this->nspace << name << "Class" << endl << "{" << endl 
+           << "  ThriftStructClass parent;" << endl << "};" << endl << "typedef struct _" 
+           << this->nspace << name << "Class " << this->nspace << name << "Class;" << endl << endl; 
+ 
+  // write the standard GObject boilerplate 
+  f_types_ << "GType " << this->nspace_lc << name_u << "_get_type (void);" << endl << "#define " 
+           << this->nspace_uc << "TYPE_" << name_uc << " (" << this->nspace_lc << name_u 
+           << "_get_type())" << endl << "#define " << this->nspace_uc << name_uc 
+           << "(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), " << this->nspace_uc << "TYPE_" << name_uc 
+           << ", " << this->nspace << name << "))" << endl << "#define " << this->nspace_uc 
+           << name_uc << "_CLASS(c) (G_TYPE_CHECK_CLASS_CAST ((c), " << this->nspace_uc << "_TYPE_" 
+           << name_uc << ", " << this->nspace << name << "Class))" << endl << "#define " 
+           << this->nspace_uc << "IS_" << name_uc << "(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), " 
+           << this->nspace_uc << "TYPE_" << name_uc << "))" << endl << "#define " << this->nspace_uc 
+           << "IS_" << name_uc << "_CLASS(c) (G_TYPE_CHECK_CLASS_TYPE ((c), " << this->nspace_uc 
+           << "TYPE_" << name_uc << "))" << endl << "#define " << this->nspace_uc << name_uc 
+           << "_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), " << this->nspace_uc << "TYPE_" 
+           << name_uc << ", " << this->nspace << name << "Class))" << endl << endl; 
+ 
+  // start writing the object implementation .c file 
+ 
+  // generate properties enum 
+  if (members.size() > 0) { 
+    f_types_impl_ << "enum _" << class_name << "Properties" << endl << "{" << endl; 
+    indent_up(); 
+    f_types_impl_ << indent() << "PROP_" << class_name_uc << "_0"; 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      string member_name_uc 
+          = to_upper_case(to_lower_case(initial_caps_to_underscores((*m_iter)->get_name()))); 
+ 
+      f_types_impl_ << "," << endl << indent() << "PROP_" << class_name_uc << "_" << member_name_uc; 
+    } 
+    f_types_impl_ << endl; 
+    indent_down(); 
+    f_types_impl_ << "};" << endl << endl; 
+  } 
+ 
+  // generate struct I/O methods 
+  string this_get = this->nspace + name + " * this_object = " + this->nspace_uc + name_uc 
+                    + "(object);"; 
+  generate_struct_reader(f_types_impl_, tstruct, "this_object->", this_get); 
+  generate_struct_writer(f_types_impl_, tstruct, "this_object->", this_get); 
+ 
+  // generate property setter and getter 
+  if (members.size() > 0) { 
+    // generate property setter 
+    function_name = class_name_lc + "_set_property"; 
+    args_indent = string(function_name.length() + 2, ' '); 
+    f_types_impl_ << "static void" << endl << function_name << " (GObject *object," << endl 
+                  << args_indent << "guint property_id," << endl << args_indent 
+                  << "const GValue *value," << endl << args_indent << "GParamSpec *pspec)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl 
+                  << endl << indent() << "switch (property_id)" << endl; 
+    scope_up(f_types_impl_); 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      t_field* member = (*m_iter); 
+      string member_name = member->get_name(); 
+      string member_name_uc 
+          = to_upper_case(to_lower_case(initial_caps_to_underscores(member_name))); 
+      t_type* member_type = get_true_type(member->get_type()); 
+ 
+      string property_identifier = "PROP_" + class_name_uc + "_" + member_name_uc; 
+ 
+      f_types_impl_ << indent() << "case " << property_identifier + ":" << endl; 
+      indent_up(); 
+ 
+      if (member_type->is_base_type()) { 
+        t_base_type* base_type = ((t_base_type*)member_type); 
+        string assign_function_name; 
+ 
+        if (base_type->get_base() == t_base_type::TYPE_STRING) { 
+          string release_function_name; 
+ 
+          f_types_impl_ << indent() << "if (self->" << member_name << " != NULL)" << endl; 
+          indent_up(); 
+ 
+          if (base_type->is_binary()) { 
+            release_function_name = "g_byte_array_unref"; 
+            assign_function_name = "g_value_dup_boxed"; 
+          } else { 
+            release_function_name = "g_free"; 
+            assign_function_name = "g_value_dup_string"; 
+          } 
+ 
+          f_types_impl_ << indent() << release_function_name << " (self->" << member_name << ");" 
+                        << endl; 
+          indent_down(); 
+        } else { 
+          switch (base_type->get_base()) { 
+          case t_base_type::TYPE_BOOL: 
+            assign_function_name = "g_value_get_boolean"; 
+            break; 
+ 
+          case t_base_type::TYPE_I8: 
+          case t_base_type::TYPE_I16: 
+          case t_base_type::TYPE_I32: 
+            assign_function_name = "g_value_get_int"; 
+            break; 
+ 
+          case t_base_type::TYPE_I64: 
+            assign_function_name = "g_value_get_int64"; 
+            break; 
+ 
+          case t_base_type::TYPE_DOUBLE: 
+            assign_function_name = "g_value_get_double"; 
+            break; 
+ 
+          default: 
+            throw "compiler error: " 
+                  "unrecognized base type \"" + base_type->get_name() + "\" " 
+                                                                        "for struct member \"" 
+                + member_name + "\""; 
+            break; 
+          } 
+        } 
+ 
+        f_types_impl_ << indent() << "self->" << member_name << " = " << assign_function_name 
+                      << " (value);" << endl; 
+      } else if (member_type->is_enum()) { 
+        f_types_impl_ << indent() << "self->" << member_name << " = g_value_get_int (value);" 
+                      << endl; 
+      } else if (member_type->is_container()) { 
+        string release_function_name; 
+        string assign_function_name; 
+ 
+        if (member_type->is_list()) { 
+          t_type* elem_type = ((t_list*)member_type)->get_elem_type(); 
+ 
+          // Lists of base types other than strings are represented as GArrays; 
+          // all others as GPtrArrays 
+          if (is_numeric(elem_type)) { 
+            release_function_name = "g_array_unref"; 
+          } else { 
+            release_function_name = "g_ptr_array_unref"; 
+          } 
+ 
+          assign_function_name = "g_value_dup_boxed"; 
+        } else if (member_type->is_set() || member_type->is_map()) { 
+          release_function_name = "g_hash_table_unref"; 
+          assign_function_name = "g_value_dup_boxed"; 
+        } 
+ 
+        f_types_impl_ << indent() << "if (self->" << member_name << " != NULL)" << endl; 
+        indent_up(); 
+        f_types_impl_ << indent() << release_function_name << " (self->" << member_name << ");" 
+                      << endl; 
+        indent_down(); 
+        f_types_impl_ << indent() << "self->" << member_name << " = " << assign_function_name 
+                      << " (value);" << endl; 
+      } else if (member_type->is_struct() || member_type->is_xception()) { 
+        f_types_impl_ << indent() << "if (self->" << member_name << " != NULL)" << endl; 
+        indent_up(); 
+        f_types_impl_ << indent() << "g_object_unref (self->" << member_name << ");" << endl; 
+        indent_down(); 
+        f_types_impl_ << indent() << "self->" << member_name << " = g_value_dup_object (value);" 
+                      << endl; 
+      } 
+ 
+      if (member->get_req() != t_field::T_REQUIRED) { 
+        f_types_impl_ << indent() << "self->__isset_" << member_name << " = TRUE;" << endl; 
+      } 
+ 
+      f_types_impl_ << indent() << "break;" << endl << endl; 
+      indent_down(); 
+    } 
+    f_types_impl_ << indent() << "default:" << endl; 
+    indent_up(); 
+    f_types_impl_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);" 
+                  << endl << indent() << "break;" << endl; 
+    indent_down(); 
+    scope_down(f_types_impl_); 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << endl; 
+ 
+    // generate property getter 
+    function_name = class_name_lc + "_get_property"; 
+    args_indent = string(function_name.length() + 2, ' '); 
+    f_types_impl_ << "static void" << endl << function_name << " (GObject *object," << endl 
+                  << args_indent << "guint property_id," << endl << args_indent << "GValue *value," 
+                  << endl << args_indent << "GParamSpec *pspec)" << endl; 
+    scope_up(f_types_impl_); 
+    f_types_impl_ << indent() << class_name << " *self = " << class_name_uc << " (object);" << endl 
+                  << endl << indent() << "switch (property_id)" << endl; 
+    scope_up(f_types_impl_); 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      t_field* member = (*m_iter); 
+      string member_name = (*m_iter)->get_name(); 
+      string member_name_uc 
+          = to_upper_case(to_lower_case(initial_caps_to_underscores(member_name))); 
+      t_type* member_type = get_true_type(member->get_type()); 
+ 
+      string property_identifier = "PROP_" + class_name_uc + "_" + member_name_uc; 
+ 
+      string setter_function_name; 
+ 
+      if (member_type->is_base_type()) { 
+        t_base_type* base_type = ((t_base_type*)member_type); 
+ 
+        switch (base_type->get_base()) { 
+        case t_base_type::TYPE_BOOL: 
+          setter_function_name = "g_value_set_boolean"; 
+          break; 
+ 
+        case t_base_type::TYPE_I8: 
+        case t_base_type::TYPE_I16: 
+        case t_base_type::TYPE_I32: 
+          setter_function_name = "g_value_set_int"; 
+          break; 
+ 
+        case t_base_type::TYPE_I64: 
+          setter_function_name = "g_value_set_int64"; 
+          break; 
+ 
+        case t_base_type::TYPE_DOUBLE: 
+          setter_function_name = "g_value_set_double"; 
+          break; 
+ 
+        case t_base_type::TYPE_STRING: 
+          if (base_type->is_binary()) { 
+            setter_function_name = "g_value_set_boxed"; 
+          } else { 
+            setter_function_name = "g_value_set_string"; 
+          } 
+          break; 
+ 
+        default: 
+          throw "compiler error: " 
+                "unrecognized base type \"" + base_type->get_name() + "\" " 
+                                                                      "for struct member \"" 
+              + member_name + "\""; 
+          break; 
+        } 
+      } else if (member_type->is_enum()) { 
+        setter_function_name = "g_value_set_int"; 
+      } else if (member_type->is_struct() || member_type->is_xception()) { 
+        setter_function_name = "g_value_set_object"; 
+      } else if (member_type->is_container()) { 
+        setter_function_name = "g_value_set_boxed"; 
+      } else { 
+        throw "compiler error: " 
+              "unrecognized type for struct member \"" + member_name + "\""; 
+      } 
+ 
+      f_types_impl_ << indent() << "case " << property_identifier + ":" << endl; 
+      indent_up(); 
+      f_types_impl_ << indent() << setter_function_name << " (value, self->" << member_name << ");" 
+                    << endl << indent() << "break;" << endl << endl; 
+      indent_down(); 
+    } 
+    f_types_impl_ << indent() << "default:" << endl; 
+    indent_up(); 
+    f_types_impl_ << indent() << "G_OBJECT_WARN_INVALID_PROPERTY_ID (object, property_id, pspec);" 
+                  << endl << indent() << "break;" << endl; 
+    indent_down(); 
+    scope_down(f_types_impl_); 
+    scope_down(f_types_impl_); 
+    f_types_impl_ << endl; 
+  } 
+ 
+  // generate the instance init function 
+ 
+  f_types_impl_ << "static void " << endl << this->nspace_lc << name_u << "_instance_init (" 
+                << this->nspace << name << " * object)" << endl << "{" << endl; 
+  indent_up(); 
+ 
+  // generate default-value structures for container-type members 
+  bool constant_declaration_output = false; 
+  bool string_list_constant_output = false; 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_field* member = *m_iter; 
+    t_const_value* member_value = member->get_value(); 
+ 
+    if (member_value != NULL) { 
+      string member_name = member->get_name(); 
+      t_type* member_type = get_true_type(member->get_type()); 
+ 
+      if (member_type->is_list()) { 
+        const vector<t_const_value*>& list = member_value->get_list(); 
+        t_type* elem_type = ((t_list*)member_type)->get_elem_type(); 
+ 
+        // Generate an array with the list literal 
+        indent(f_types_impl_) << "static " << type_name(elem_type, false, true) << " __default_" 
+                              << member_name << "[" << list.size() << "] = " << endl; 
+        indent_up(); 
+        f_types_impl_ << indent() << constant_literal(member_type, member_value) << ";" << endl; 
+        indent_down(); 
+ 
+        constant_declaration_output = true; 
+ 
+        // If we are generating values for a pointer array (i.e. a list of 
+        // strings), set a flag so we know to also declare an index variable to 
+        // use in pre-populating the array 
+        if (elem_type->is_string()) { 
+          string_list_constant_output = true; 
+        } 
+      } 
+ 
+      // TODO: Handle container types other than list 
+    } 
+  } 
+  if (constant_declaration_output) { 
+    if (string_list_constant_output) { 
+      indent(f_types_impl_) << "unsigned int list_index;" << endl; 
+    } 
+ 
+    f_types_impl_ << endl; 
+  } 
+ 
+  // satisfy compilers with -Wall turned on 
+  indent(f_types_impl_) << "/* satisfy -Wall */" << endl << indent() 
+                        << "THRIFT_UNUSED_VAR (object);" << endl; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = get_true_type((*m_iter)->get_type()); 
+    if (t->is_base_type()) { 
+      string dval = " = "; 
+      if (t->is_enum()) { 
+        dval += "(" + type_name(t) + ")"; 
+      } 
+      t_const_value* cv = (*m_iter)->get_value(); 
+      if (cv != NULL) { 
+        dval += constant_value("", t, cv); 
+      } else { 
+        dval += t->is_string() ? "NULL" : "0"; 
+      } 
+      indent(f_types_impl_) << "object->" << (*m_iter)->get_name() << dval << ";" << endl; 
+    } else if (t->is_struct()) { 
+      string name = (*m_iter)->get_name(); 
+      string type_name_uc 
+          = to_upper_case(initial_caps_to_underscores((*m_iter)->get_type()->get_name())); 
+      indent(f_types_impl_) << "object->" << name << " = g_object_new (" << this->nspace_uc 
+                            << "TYPE_" << type_name_uc << ", NULL);" << endl; 
+    } else if (t->is_xception()) { 
+      string name = (*m_iter)->get_name(); 
+      indent(f_types_impl_) << "object->" << name << " = NULL;" << endl; 
+    } else if (t->is_container()) { 
+      string name = (*m_iter)->get_name(); 
+      string init_function; 
+      t_type* etype = NULL; 
+ 
+      if (t->is_map()) { 
+        t_type* key = ((t_map*)t)->get_key_type(); 
+        t_type* value = ((t_map*)t)->get_val_type(); 
+        init_function = generate_new_hash_from_type(key, value); 
+      } else if (t->is_set()) { 
+        etype = ((t_set*)t)->get_elem_type(); 
+        init_function = generate_new_hash_from_type(etype, NULL); 
+      } else if (t->is_list()) { 
+        etype = ((t_list*)t)->get_elem_type(); 
+        init_function = generate_new_array_from_type(etype); 
+      } 
+ 
+      indent(f_types_impl_) << "object->" << name << " = " << init_function << endl; 
+ 
+      // Pre-populate the container with the specified default values, if any 
+      if ((*m_iter)->get_value()) { 
+        t_const_value* member_value = (*m_iter)->get_value(); 
+ 
+        if (t->is_list()) { 
+          const vector<t_const_value*>& list = member_value->get_list(); 
+ 
+          if (is_numeric(etype)) { 
+            indent(f_types_impl_) << 
+              "g_array_append_vals (object->" << name << ", &__default_" << 
+              name << ", " << list.size() << ");" << endl; 
+          } 
+          else { 
+            indent(f_types_impl_) << 
+              "for (list_index = 0; list_index < " << list.size() << "; " << 
+              "list_index += 1)" << endl; 
+            indent_up(); 
+            indent(f_types_impl_) << 
+              "g_ptr_array_add (object->" << name << "," << endl << 
+              indent() << string(17, ' ') << "g_strdup (__default_" << 
+              name << "[list_index]));" << endl; 
+            indent_down(); 
+          } 
+        } 
+ 
+        // TODO: Handle container types other than list 
+      } 
+    } 
+ 
+    /* if not required, initialize the __isset variable */ 
+    if ((*m_iter)->get_req() != t_field::T_REQUIRED) { 
+      indent(f_types_impl_) << "object->__isset_" << (*m_iter)->get_name() << " = FALSE;" << endl; 
+    } 
+  } 
+ 
+  indent_down(); 
+  f_types_impl_ << "}" << endl << endl; 
+ 
+  /* create the destructor */ 
+  f_types_impl_ << "static void " << endl << this->nspace_lc << name_u 
+                << "_finalize (GObject *object)" << endl << "{" << endl; 
+  indent_up(); 
+ 
+  f_types_impl_ << indent() << this->nspace << name << " *tobject = " << this->nspace_uc << name_uc 
+                << " (object);" << endl << endl; 
+ 
+  f_types_impl_ << indent() << "/* satisfy -Wall in case we don't use tobject */" << endl 
+                << indent() << "THRIFT_UNUSED_VAR (tobject);" << endl; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = get_true_type((*m_iter)->get_type()); 
+    if (t->is_container()) { 
+      string name = (*m_iter)->get_name(); 
+      if (t->is_map() || t->is_set()) { 
+        f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl; 
+        f_types_impl_ << indent() << "{" << endl; 
+        indent_up(); 
+        f_types_impl_ << indent() << "g_hash_table_destroy (tobject->" << name << ");" << endl; 
+        f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl; 
+        indent_down(); 
+        f_types_impl_ << indent() << "}" << endl; 
+      } else if (t->is_list()) { 
+        t_type* etype = ((t_list*)t)->get_elem_type(); 
+        string destructor_function = "g_ptr_array_unref"; 
+ 
+        if (etype->is_base_type()) { 
+          t_base_type::t_base tbase = ((t_base_type*)etype)->get_base(); 
+          switch (tbase) { 
+          case t_base_type::TYPE_VOID: 
+            throw "compiler error: cannot determine array type"; 
+          case t_base_type::TYPE_BOOL: 
+          case t_base_type::TYPE_I8: 
+          case t_base_type::TYPE_I16: 
+          case t_base_type::TYPE_I32: 
+          case t_base_type::TYPE_I64: 
+          case t_base_type::TYPE_DOUBLE: 
+            destructor_function = "g_array_unref"; 
+            break; 
+          case t_base_type::TYPE_STRING: 
+            break; 
+          default: 
+            throw "compiler error: no array info for type"; 
+          } 
+        } else if (etype->is_enum()) { 
+          destructor_function = "g_array_unref"; 
+        } 
+ 
+        f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl; 
+        f_types_impl_ << indent() << "{" << endl; 
+        indent_up(); 
+        f_types_impl_ << indent() << destructor_function << " (tobject->" << name << ");" << endl; 
+        f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl; 
+        indent_down(); 
+        f_types_impl_ << indent() << "}" << endl; 
+      } 
+    } else if (t->is_struct() || t->is_xception()) { 
+      string name = (*m_iter)->get_name(); 
+      // TODO: g_clear_object needs glib >= 2.28 
+      // f_types_impl_ << indent() << "g_clear_object (&(tobject->" << name << "));" << endl; 
+      // does g_object_unref the trick? 
+      f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl; 
+      f_types_impl_ << indent() << "{" << endl; 
+      indent_up(); 
+      f_types_impl_ << indent() << "g_object_unref(tobject->" << name << ");" << endl; 
+      f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl; 
+      indent_down(); 
+      f_types_impl_ << indent() << "}" << endl; 
+    } else if (t->is_string()) { 
+      string name = (*m_iter)->get_name(); 
+      f_types_impl_ << indent() << "if (tobject->" << name << " != NULL)" << endl; 
+      f_types_impl_ << indent() << "{" << endl; 
+      indent_up(); 
+      f_types_impl_ << indent() << generate_free_func_from_type(t) << "(tobject->" << name << ");" 
+                    << endl; 
+      f_types_impl_ << indent() << "tobject->" << name << " = NULL;" << endl; 
+      indent_down(); 
+      f_types_impl_ << indent() << "}" << endl; 
+    } 
+  } 
+ 
+  indent_down(); 
+  f_types_impl_ << "}" << endl << endl; 
+ 
+  // generate the class init function 
+ 
+  f_types_impl_ << "static void" << endl << class_name_lc << "_class_init (" << class_name 
+                << "Class * cls)" << endl; 
+  scope_up(f_types_impl_); 
+ 
+  f_types_impl_ << indent() << "GObjectClass *gobject_class = G_OBJECT_CLASS (cls);" << endl 
+                << indent() << "ThriftStructClass *struct_class = " 
+                << "THRIFT_STRUCT_CLASS (cls);" << endl << endl << indent() 
+                << "struct_class->read = " << class_name_lc << "_read;" << endl << indent() 
+                << "struct_class->write = " << class_name_lc << "_write;" << endl << endl 
+                << indent() << "gobject_class->finalize = " << class_name_lc << "_finalize;" 
+                << endl; 
+  if (members.size() > 0) { 
+    f_types_impl_ << indent() << "gobject_class->get_property = " << class_name_lc 
+                  << "_get_property;" << endl << indent() 
+                  << "gobject_class->set_property = " << class_name_lc << "_set_property;" << endl; 
+ 
+    // install a property for each member 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      t_field* member = (*m_iter); 
+      string member_name = member->get_name(); 
+      string member_name_uc 
+          = to_upper_case(to_lower_case(initial_caps_to_underscores(member_name))); 
+      t_type* member_type = get_true_type(member->get_type()); 
+      t_const_value* member_value = member->get_value(); 
+ 
+      string property_identifier = "PROP_" + class_name_uc + "_" + member_name_uc; 
+ 
+      f_types_impl_ << endl << indent() << "g_object_class_install_property" << endl; 
+      indent_up(); 
+      args_indent = indent() + ' '; 
+      f_types_impl_ << indent() << "(gobject_class," << endl << args_indent << property_identifier 
+                    << "," << endl << args_indent; 
+ 
+      if (member_type->is_base_type()) { 
+        t_base_type::t_base base_type = ((t_base_type*)member_type)->get_base(); 
+ 
+        if (base_type == t_base_type::TYPE_STRING) { 
+          if (((t_base_type*)member_type)->is_binary()) { 
+            args_indent += string(20, ' '); 
+            f_types_impl_ << "g_param_spec_boxed (\"" << member_name << "\"," << endl << args_indent 
+                          << "NULL," << endl << args_indent << "NULL," << endl << args_indent 
+                          << "G_TYPE_BYTE_ARRAY," << endl << args_indent << "G_PARAM_READWRITE));" 
+                          << endl; 
+          } else { 
+            args_indent += string(21, ' '); 
+            f_types_impl_ << "g_param_spec_string (\"" << member_name << "\"," << endl 
+                          << args_indent << "NULL," << endl << args_indent << "NULL," << endl 
+                          << args_indent 
+                          << ((member_value != NULL) ? "\"" + member_value->get_string() + "\"" 
+                                                     : "NULL") << "," << endl << args_indent 
+                          << "G_PARAM_READWRITE));" << endl; 
+          } 
+        } else if (base_type == t_base_type::TYPE_BOOL) { 
+          args_indent += string(22, ' '); 
+          f_types_impl_ << "g_param_spec_boolean (\"" << member_name << "\"," << endl << args_indent 
+                        << "NULL," << endl << args_indent << "NULL," << endl << args_indent 
+                        << (((member_value != NULL) && (member_value->get_integer() != 0)) 
+                                ? "TRUE" 
+                                : "FALSE") << "," << endl << args_indent << "G_PARAM_READWRITE));" 
+                        << endl; 
+        } else if ((base_type == t_base_type::TYPE_I8) || (base_type == t_base_type::TYPE_I16) 
+                   || (base_type == t_base_type::TYPE_I32) || (base_type == t_base_type::TYPE_I64) 
+                   || (base_type == t_base_type::TYPE_DOUBLE)) { 
+          string param_spec_function_name = "g_param_spec_int"; 
+          string min_value; 
+          string max_value; 
+          ostringstream default_value; 
+ 
+          switch (base_type) { 
+          case t_base_type::TYPE_I8: 
+            min_value = "G_MININT8"; 
+            max_value = "G_MAXINT8"; 
+            break; 
+ 
+          case t_base_type::TYPE_I16: 
+            min_value = "G_MININT16"; 
+            max_value = "G_MAXINT16"; 
+            break; 
+ 
+          case t_base_type::TYPE_I32: 
+            min_value = "G_MININT32"; 
+            max_value = "G_MAXINT32"; 
+            break; 
+ 
+          case t_base_type::TYPE_I64: 
+            param_spec_function_name = "g_param_spec_int64"; 
+            min_value = "G_MININT64"; 
+            max_value = "G_MAXINT64"; 
+            break; 
+ 
+          case t_base_type::TYPE_DOUBLE: 
+            param_spec_function_name = "g_param_spec_double"; 
+            min_value = "-INFINITY"; 
+            max_value = "INFINITY"; 
+            break; 
+ 
+          default: 
+            throw "compiler error: " 
+                  "unrecognized base type \"" + member_type->get_name() + "\" " 
+                                                                          "for struct member \"" 
+                + member_name + "\""; 
+            break; 
+          } 
+ 
+          if (member_value != NULL) { 
+            default_value << (base_type == t_base_type::TYPE_DOUBLE ? member_value->get_double() 
+                                                                    : member_value->get_integer()); 
+          } else { 
+            default_value << "0"; 
+          } 
+ 
+          args_indent += string(param_spec_function_name.length() + 2, ' '); 
+          f_types_impl_ << param_spec_function_name << " (\"" << member_name << "\"," << endl 
+                        << args_indent << "NULL," << endl << args_indent << "NULL," << endl 
+                        << args_indent << min_value << "," << endl << args_indent << max_value 
+                        << "," << endl << args_indent << default_value.str() << "," << endl 
+                        << args_indent << "G_PARAM_READWRITE));" << endl; 
+        } 
+ 
+        indent_down(); 
+      } else if (member_type->is_enum()) { 
+        t_enum_value* enum_min_value = ((t_enum*)member_type)->get_min_value(); 
+        t_enum_value* enum_max_value = ((t_enum*)member_type)->get_max_value(); 
+        int min_value = (enum_min_value != NULL) ? enum_min_value->get_value() : 0; 
+        int max_value = (enum_max_value != NULL) ? enum_max_value->get_value() : 0; 
+ 
+        args_indent += string(18, ' '); 
+        f_types_impl_ << "g_param_spec_int (\"" << member_name << "\"," << endl << args_indent 
+                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent 
+                      << min_value << "," << endl << args_indent << max_value << "," << endl 
+                      << args_indent << min_value << "," << endl << args_indent 
+                      << "G_PARAM_READWRITE));" << endl; 
+        indent_down(); 
+      } else if (member_type->is_struct() || member_type->is_xception()) { 
+        string param_type = this->nspace_uc + "TYPE_" 
+                            + to_upper_case(initial_caps_to_underscores(member_type->get_name())); 
+ 
+        args_indent += string(20, ' '); 
+        f_types_impl_ << "g_param_spec_object (\"" << member_name << "\"," << endl << args_indent 
+                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent 
+                      << param_type << "," << endl << args_indent << "G_PARAM_READWRITE));" << endl; 
+        indent_down(); 
+      } else if (member_type->is_list()) { 
+        t_type* elem_type = ((t_list*)member_type)->get_elem_type(); 
+        string param_type; 
+ 
+        if (elem_type->is_base_type() && !elem_type->is_string()) { 
+          param_type = "G_TYPE_ARRAY"; 
+        } else { 
+          param_type = "G_TYPE_PTR_ARRAY"; 
+        } 
+ 
+        args_indent += string(20, ' '); 
+        f_types_impl_ << "g_param_spec_boxed (\"" << member_name << "\"," << endl << args_indent 
+                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent 
+                      << param_type << "," << endl << args_indent << "G_PARAM_READWRITE));" << endl; 
+        indent_down(); 
+      } else if (member_type->is_set() || member_type->is_map()) { 
+        args_indent += string(20, ' '); 
+        f_types_impl_ << "g_param_spec_boxed (\"" << member_name << "\"," << endl << args_indent 
+                      << "NULL," << endl << args_indent << "NULL," << endl << args_indent 
+                      << "G_TYPE_HASH_TABLE," << endl << args_indent << "G_PARAM_READWRITE));" 
+                      << endl; 
+        indent_down(); 
+      } 
+    } 
+  } 
+  scope_down(f_types_impl_); 
+  f_types_impl_ << endl; 
+ 
+  f_types_impl_ << "GType" << endl << this->nspace_lc << name_u << "_get_type (void)" << endl << "{" 
+                << endl << "  static GType type = 0;" << endl << endl << "  if (type == 0) " << endl 
+                << "  {" << endl << "    static const GTypeInfo type_info = " << endl << "    {" 
+                << endl << "      sizeof (" << this->nspace << name << "Class)," << endl 
+                << "      NULL, /* base_init */" << endl << "      NULL, /* base_finalize */" 
+                << endl << "      (GClassInitFunc) " << this->nspace_lc << name_u << "_class_init," 
+                << endl << "      NULL, /* class_finalize */" << endl 
+                << "      NULL, /* class_data */" << endl << "      sizeof (" << this->nspace 
+                << name << ")," << endl << "      0, /* n_preallocs */" << endl 
+                << "      (GInstanceInitFunc) " << this->nspace_lc << name_u << "_instance_init," 
+                << endl << "      NULL, /* value_table */" << endl << "    };" << endl << endl 
+                << "    type = g_type_register_static (THRIFT_TYPE_STRUCT, " << endl 
+                << "                                   \"" << this->nspace << name << "Type\"," 
+                << endl << "                                   &type_info, 0);" << endl << "  }" 
+                << endl << endl << "  return type;" << endl << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates functions to write Thrift structures to a stream. 
+ */ 
+void t_c_glib_generator::generate_struct_writer(ostream& out, 
+                                                t_struct* tstruct, 
+                                                string this_name, 
+                                                string this_get, 
+                                                bool is_function) { 
+  string name = tstruct->get_name(); 
+  string name_u = initial_caps_to_underscores(name); 
+  string name_uc = to_upper_case(name_u); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  int error_ret = 0; 
+ 
+  if (is_function) { 
+    error_ret = -1; 
+    indent(out) << "static gint32" << endl << this->nspace_lc << name_u 
+                << "_write (ThriftStruct *object, ThriftProtocol *protocol, GError **error)" 
+                << endl; 
+  } 
+  indent(out) << "{" << endl; 
+  indent_up(); 
+ 
+  out << indent() << "gint32 ret;" << endl << indent() << "gint32 xfer = 0;" << endl << endl; 
+ 
+  indent(out) << this_get << endl; 
+  // satisfy -Wall in the case of an empty struct 
+  if (!this_get.empty()) { 
+    indent(out) << "THRIFT_UNUSED_VAR (this_object);" << endl; 
+  } 
+ 
+  out << indent() << "if ((ret = thrift_protocol_write_struct_begin (protocol, \"" << name 
+      << "\", error)) < 0)" << endl << indent() << "  return " << error_ret << ";" << endl 
+      << indent() << "xfer += ret;" << endl; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() == t_field::T_OPTIONAL) { 
+      indent(out) << "if (this_object->__isset_" << (*f_iter)->get_name() << " == TRUE) {" << endl; 
+      indent_up(); 
+    } 
+ 
+    out << indent() << "if ((ret = thrift_protocol_write_field_begin (protocol, " 
+        << "\"" << (*f_iter)->get_name() << "\", " << type_to_enum((*f_iter)->get_type()) << ", " 
+        << (*f_iter)->get_key() << ", error)) < 0)" << endl << indent() << "  return " << error_ret 
+        << ";" << endl << indent() << "xfer += ret;" << endl; 
+    generate_serialize_field(out, *f_iter, this_name, "", error_ret); 
+    out << indent() << "if ((ret = thrift_protocol_write_field_end (protocol, error)) < 0)" << endl 
+        << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" 
+        << endl; 
+ 
+    if ((*f_iter)->get_req() == t_field::T_OPTIONAL) { 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+  } 
+ 
+  // write the struct map 
+  out << indent() << "if ((ret = thrift_protocol_write_field_stop (protocol, error)) < 0)" << endl 
+      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl 
+      << indent() << "if ((ret = thrift_protocol_write_struct_end (protocol, error)) < 0)" << endl 
+      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl 
+      << endl; 
+ 
+  if (is_function) { 
+    indent(out) << "return xfer;" << endl; 
+  } 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates code to read Thrift structures from a stream. 
+ */ 
+void t_c_glib_generator::generate_struct_reader(ostream& out, 
+                                                t_struct* tstruct, 
+                                                string this_name, 
+                                                string this_get, 
+                                                bool is_function) { 
+  string name = tstruct->get_name(); 
+  string name_u = initial_caps_to_underscores(name); 
+  string name_uc = to_upper_case(name_u); 
+  int error_ret = 0; 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  if (is_function) { 
+    error_ret = -1; 
+    indent(out) << "/* reads a " << name_u << " object */" << endl << "static gint32" << endl 
+                << this->nspace_lc << name_u 
+                << "_read (ThriftStruct *object, ThriftProtocol *protocol, GError **error)" << endl; 
+  } 
+ 
+  indent(out) << "{" << endl; 
+  indent_up(); 
+ 
+  // declare stack temp variables 
+  out << indent() << "gint32 ret;" << endl << indent() << "gint32 xfer = 0;" << endl << indent() 
+      << "gchar *name = NULL;" << endl << indent() << "ThriftType ftype;" << endl << indent() 
+      << "gint16 fid;" << endl << indent() << "guint32 len = 0;" << endl << indent() 
+      << "gpointer data = NULL;" << endl << indent() << this_get << endl; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() == t_field::T_REQUIRED) { 
+      indent(out) << "gboolean isset_" << (*f_iter)->get_name() << " = FALSE;" << endl; 
+    } 
+  } 
+ 
+  out << endl; 
+ 
+  // satisfy -Wall in case we don't use some variables 
+  out << indent() << "/* satisfy -Wall in case these aren't used */" << endl << indent() 
+      << "THRIFT_UNUSED_VAR (len);" << endl << indent() << "THRIFT_UNUSED_VAR (data);" << endl; 
+ 
+  if (!this_get.empty()) { 
+    out << indent() << "THRIFT_UNUSED_VAR (this_object);" << endl; 
+  } 
+  out << endl; 
+ 
+  // read the beginning of the structure marker 
+  out << indent() << "/* read the struct begin marker */" << endl << indent() 
+      << "if ((ret = thrift_protocol_read_struct_begin (protocol, &name, error)) < 0)" << endl 
+      << indent() << "{" << endl << indent() << "  if (name) g_free (name);" << endl << indent() 
+      << "  return " << error_ret << ";" << endl << indent() << "}" << endl << indent() 
+      << "xfer += ret;" << endl << indent() << "if (name) g_free (name);" << endl << indent() 
+      << "name = NULL;" << endl << endl; 
+ 
+  // read the struct fields 
+  out << indent() << "/* read the struct fields */" << endl << indent() << "while (1)" << endl; 
+  scope_up(out); 
+ 
+  // read beginning field marker 
+  out << indent() << "/* read the beginning of a field */" << endl << indent() 
+      << "if ((ret = thrift_protocol_read_field_begin (protocol, &name, &ftype, &fid, error)) < 0)" 
+      << endl << indent() << "{" << endl << indent() << "  if (name) g_free (name);" << endl 
+      << indent() << "  return " << error_ret << ";" << endl << indent() << "}" << endl << indent() 
+      << "xfer += ret;" << endl << indent() << "if (name) g_free (name);" << endl << indent() 
+      << "name = NULL;" << endl << endl; 
+ 
+  // check for field STOP marker 
+  out << indent() << "/* break if we get a STOP field */" << endl << indent() 
+      << "if (ftype == T_STOP)" << endl << indent() << "{" << endl << indent() << "  break;" << endl 
+      << indent() << "}" << endl << endl; 
+ 
+  // switch depending on the field type 
+  indent(out) << "switch (fid)" << endl; 
+ 
+  // start switch 
+  scope_up(out); 
+ 
+  // generate deserialization code for known types 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl; 
+    indent_up(); 
+    indent(out) << "if (ftype == " << type_to_enum((*f_iter)->get_type()) << ")" << endl; 
+    indent(out) << "{" << endl; 
+ 
+    indent_up(); 
+    // generate deserialize field 
+    generate_deserialize_field(out, *f_iter, this_name, "", error_ret, false); 
+    indent_down(); 
+ 
+    out << indent() << "} else {" << endl << indent() 
+        << "  if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)" << endl << indent() 
+        << "    return " << error_ret << ";" << endl << indent() << "  xfer += ret;" << endl 
+        << indent() << "}" << endl << indent() << "break;" << endl; 
+    indent_down(); 
+  } 
+ 
+  // create the default case 
+  out << indent() << "default:" << endl << indent() 
+      << "  if ((ret = thrift_protocol_skip (protocol, ftype, error)) < 0)" << endl << indent() 
+      << "    return " << error_ret << ";" << endl << indent() << "  xfer += ret;" << endl 
+      << indent() << "  break;" << endl; 
+ 
+  // end switch 
+  scope_down(out); 
+ 
+  // read field end marker 
+  out << indent() << "if ((ret = thrift_protocol_read_field_end (protocol, error)) < 0)" << endl 
+      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl; 
+ 
+  // end while loop 
+  scope_down(out); 
+  out << endl; 
+ 
+  // read the end of the structure 
+  out << indent() << "if ((ret = thrift_protocol_read_struct_end (protocol, error)) < 0)" << endl 
+      << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl 
+      << endl; 
+ 
+  // if a required field is missing, throw an error 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() == t_field::T_REQUIRED) { 
+      out << indent() << "if (!isset_" << (*f_iter)->get_name() << ")" << endl << indent() << "{" 
+          << endl << indent() << "  g_set_error (error, THRIFT_PROTOCOL_ERROR," << endl << indent() 
+          << "               THRIFT_PROTOCOL_ERROR_INVALID_DATA," << endl << indent() 
+          << "               \"missing field\");" << endl << indent() << "  return -1;" << endl 
+          << indent() << "}" << endl << endl; 
+    } 
+  } 
+ 
+  if (is_function) { 
+    indent(out) << "return xfer;" << endl; 
+  } 
+ 
+  // end the function/structure 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_c_glib_generator::generate_serialize_field(ostream& out, 
+                                                  t_field* tfield, 
+                                                  string prefix, 
+                                                  string suffix, 
+                                                  int error_ret) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+  string name = prefix + tfield->get_name() + suffix; 
+ 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + name; 
+  } 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_serialize_struct(out, (t_struct*)type, name, error_ret); 
+  } else if (type->is_container()) { 
+    generate_serialize_container(out, type, name, error_ret); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+    indent(out) << "if ((ret = thrift_protocol_write_"; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + name; 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "bool (protocol, " << name; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "byte (protocol, " << name; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "i16 (protocol, " << name; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "i32 (protocol, " << name; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "i64 (protocol, " << name; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "double (protocol, " << name; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "binary (protocol, " << name << " ? ((GByteArray *) " << name << ")->data : NULL, " 
+              << name << " ? ((GByteArray *) " << name << ")->len : 0"; 
+        } else { 
+          out << "string (protocol, " << name; 
+        } 
+        break; 
+      default: 
+        throw "compiler error: no C writer for base type " + t_base_type::t_base_name(tbase) + name; 
+      } 
+    } else { 
+      out << "i32 (protocol, (gint32) " << name; 
+    } 
+    out << ", error)) < 0)" << endl 
+        << indent() << "  return " << error_ret << ";" << endl 
+        << indent() << "xfer += ret;" << endl << endl; 
+  } else { 
+    throw std::logic_error("DO NOT KNOW HOW TO SERIALIZE FIELD '" + name + "' TYPE '" 
+                           + type_name(type)); 
+  } 
+} 
+ 
+void t_c_glib_generator::generate_serialize_struct(ostream& out, 
+                                                   t_struct* tstruct, 
+                                                   string prefix, 
+                                                   int error_ret) { 
+  (void)tstruct; 
+  out << indent() << "if ((ret = thrift_struct_write (THRIFT_STRUCT (" << prefix 
+      << "), protocol, error)) < 0)" << endl << indent() << "  return " << error_ret << ";" << endl 
+      << indent() << "xfer += ret;" << endl << endl; 
+} 
+ 
+void t_c_glib_generator::generate_serialize_container(ostream& out, 
+                                                      t_type* ttype, 
+                                                      string prefix, 
+                                                      int error_ret) { 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    t_type* tkey = ((t_map*)ttype)->get_key_type(); 
+    t_type* tval = ((t_map*)ttype)->get_val_type(); 
+    string tkey_name = type_name(tkey); 
+    string tval_name = type_name(tval); 
+    string tkey_ptr; 
+    string tval_ptr; 
+    string keyname = tmp("key"); 
+    string valname = tmp("val"); 
+ 
+    declore_local_variable_for_write(out, tkey, keyname); 
+    declore_local_variable_for_write(out, tval, valname); 
+ 
+    /* If either the key or value type is a typedef, find its underlying type so 
+       we can correctly determine how to generate a pointer to it */ 
+    tkey = get_true_type(tkey); 
+    tval = get_true_type(tval); 
+ 
+    tkey_ptr = tkey->is_string() || !tkey->is_base_type() ? "" : "*"; 
+    tval_ptr = tval->is_string() || !tval->is_base_type() ? "" : "*"; 
+ 
+    /* 
+     * Some ugliness here.  To maximize backwards compatibility, we 
+     * avoid using GHashTableIter and instead get a GList of all keys, 
+     * then copy it into a array on the stack, and free it. 
+     * This is because we may exit early before we get a chance to free the 
+     * GList. 
+     */ 
+    out << indent() << "GList *key_list = NULL, *iter = NULL;" << endl 
+        << indent() << tkey_name << tkey_ptr << "* keys;" << endl 
+        << indent() << "int i = 0, key_count;" << endl 
+        << endl 
+        << indent() << "if ((ret = thrift_protocol_write_map_begin (protocol, " 
+        << type_to_enum(tkey) << ", " << type_to_enum(tval) << ", " << prefix << " ? " 
+        << "(gint32) g_hash_table_size ((GHashTable *) " << prefix << ") : 0" 
+        << ", error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl 
+        << indent() << "if (" << prefix << ")" << endl 
+        << indent() << "  g_hash_table_foreach ((GHashTable *) " << prefix 
+        << ", thrift_hash_table_get_keys, &key_list);" << endl 
+        << indent() << "key_count = g_list_length (key_list);" << endl 
+        << indent() << "keys = g_newa (" << tkey_name << tkey_ptr 
+        << ", key_count);" << endl 
+        << indent() << "for (iter = g_list_first (key_list); iter; " 
+           "iter = iter->next)" << endl; 
+    indent_up(); 
+    out << indent() << "keys[i++] = (" << tkey_name << tkey_ptr 
+        << ") iter->data;" << endl; 
+    indent_down(); 
+    out << indent() << "g_list_free (key_list);" << endl 
+        << endl 
+        << indent() << "for (i = 0; i < key_count; ++i)" << endl; 
+    scope_up(out); 
+    out << indent() << keyname << " = keys[i];" << endl 
+        << indent() << valname << " = (" << tval_name << tval_ptr 
+        << ") g_hash_table_lookup (((GHashTable *) " << prefix 
+        << "), (gpointer) " << keyname << ");" << endl 
+        << endl; 
+    generate_serialize_map_element(out, 
+                                   (t_map*)ttype, 
+                                   tkey_ptr + " " + keyname, 
+                                   tval_ptr + " " + valname, 
+                                   error_ret); 
+    scope_down(out); 
+    out << indent() << "if ((ret = thrift_protocol_write_map_end (protocol, " 
+           "error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl; 
+  } else if (ttype->is_set()) { 
+    t_type* telem = ((t_set*)ttype)->get_elem_type(); 
+    string telem_name = type_name(telem); 
+    string telem_ptr = telem->is_string() || !telem->is_base_type() ? "" : "*"; 
+    out << indent() << "GList *key_list = NULL, *iter = NULL;" << endl 
+        << indent() << telem_name << telem_ptr << "* keys;" << endl 
+        << indent() << "int i = 0, key_count;" << endl 
+        << indent() << telem_name << telem_ptr << " elem;" << endl 
+        << indent() << "gpointer value;" << endl 
+        << indent() << "THRIFT_UNUSED_VAR (value);" << endl 
+        << endl 
+        << indent() << "if ((ret = thrift_protocol_write_set_begin (protocol, " 
+        << type_to_enum(telem) << ", " << prefix << " ? " 
+        << "(gint32) g_hash_table_size ((GHashTable *) " << prefix << ") : 0" 
+        << ", error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl 
+        << indent() << "if (" << prefix << ")" << endl 
+        << indent() << "  g_hash_table_foreach ((GHashTable *) " << prefix 
+        << ", thrift_hash_table_get_keys, &key_list);" << endl 
+        << indent() << "key_count = g_list_length (key_list);" << endl 
+        << indent() << "keys = g_newa (" << telem_name << telem_ptr 
+        << ", key_count);" << endl 
+        << indent() << "for (iter = g_list_first (key_list); iter; " 
+           "iter = iter->next)" << endl; 
+    indent_up(); 
+    out << indent() << "keys[i++] = (" << telem_name << telem_ptr 
+        << ") iter->data;" << endl; 
+    indent_down(); 
+    out << indent() << "g_list_free (key_list);" << endl 
+        << endl 
+        << indent() << "for (i = 0; i < key_count; ++i)" << endl; 
+    scope_up(out); 
+    out << indent() << "elem = keys[i];" << endl 
+        << indent() << "value = (gpointer) g_hash_table_lookup " 
+           "(((GHashTable *) " << prefix << "), (gpointer) elem);" << endl 
+        << endl; 
+    generate_serialize_set_element(out, 
+                                   (t_set*)ttype, 
+                                   telem_ptr + "elem", 
+                                   error_ret); 
+    scope_down(out); 
+    out << indent() << "if ((ret = thrift_protocol_write_set_end (protocol, " 
+           "error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl; 
+  } else if (ttype->is_list()) { 
+    string length = "(" + prefix + " ? " + prefix + "->len : 0)"; 
+    string i = tmp("i"); 
+    out << indent() << "guint " << i << ";" << endl 
+        << endl 
+        << indent() << "if ((ret = thrift_protocol_write_list_begin (protocol, " 
+        << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", (gint32) " 
+        << length << ", error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl 
+        << indent() << "for (" << i << " = 0; " << i << " < " << length << "; " 
+        << i << "++)" << endl; 
+    scope_up(out); 
+    generate_serialize_list_element(out, (t_list*)ttype, prefix, i, error_ret); 
+    scope_down(out); 
+    out << indent() << "if ((ret = thrift_protocol_write_list_end (protocol, " 
+           "error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+void t_c_glib_generator::generate_serialize_map_element(ostream& out, 
+                                                        t_map* tmap, 
+                                                        string key, 
+                                                        string value, 
+                                                        int error_ret) { 
+  t_field kfield(tmap->get_key_type(), key); 
+  generate_serialize_field(out, &kfield, "", "", error_ret); 
+ 
+  t_field vfield(tmap->get_val_type(), value); 
+  generate_serialize_field(out, &vfield, "", "", error_ret); 
+} 
+ 
+void t_c_glib_generator::generate_serialize_set_element(ostream& out, 
+                                                        t_set* tset, 
+                                                        string element, 
+                                                        int error_ret) { 
+  t_field efield(tset->get_elem_type(), element); 
+  generate_serialize_field(out, &efield, "", "", error_ret); 
+} 
+ 
+void t_c_glib_generator::generate_serialize_list_element(ostream& out, 
+                                                         t_list* tlist, 
+                                                         string list, 
+                                                         string index, 
+                                                         int error_ret) { 
+  t_type* ttype = get_true_type(tlist->get_elem_type()); 
+ 
+  // cast to non-const 
+  string cast = ""; 
+  string name = "g_ptr_array_index ((GPtrArray *) " + list + ", " + index + ")"; 
+ 
+  if (ttype->is_void()) { 
+    throw std::runtime_error("compiler error: list element type cannot be void"); 
+  } else if (is_numeric(ttype)) { 
+    name = "g_array_index (" + list + ", " + base_type_name(ttype) + ", " + index + ")"; 
+  } else if (ttype->is_string()) { 
+    cast = "(gchar*)"; 
+  } else if (ttype->is_map() || ttype->is_set()) { 
+    cast = "(GHashTable*)"; 
+  } else if (ttype->is_list()) { 
+    t_type* etype = ((t_list*)ttype)->get_elem_type(); 
+    if (etype->is_void()) { 
+      throw std::runtime_error("compiler error: list element type cannot be void"); 
+    } 
+    cast = is_numeric(etype) ? "(GArray*)" : "(GPtrArray*)"; 
+  } 
+ 
+  t_field efield(ttype, "(" + cast + name + ")"); 
+  generate_serialize_field(out, &efield, "", "", error_ret); 
+} 
+ 
+/* deserializes a field of any type. */ 
+void t_c_glib_generator::generate_deserialize_field(ostream& out, 
+                                                    t_field* tfield, 
+                                                    string prefix, 
+                                                    string suffix, 
+                                                    int error_ret, 
+                                                    bool allocate) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+ 
+  if (type->is_void()) { 
+    throw std::runtime_error("CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix 
+                             + tfield->get_name()); 
+  } 
+ 
+  string name = prefix + tfield->get_name() + suffix; 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_deserialize_struct(out, (t_struct*)type, name, error_ret, allocate); 
+  } else if (type->is_container()) { 
+    generate_deserialize_container(out, type, name, error_ret); 
+  } else if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    if (tbase == t_base_type::TYPE_STRING) { 
+      indent(out) << "if (" << name << " != NULL)" << endl << indent() << "{" << endl; 
+      indent_up(); 
+      indent(out) << "g_free(" << name << ");" << endl << indent() << name << " = NULL;" << endl; 
+      indent_down(); 
+      indent(out) << "}" << endl << endl; 
+    } 
+    indent(out) << "if ((ret = thrift_protocol_read_"; 
+ 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "compiler error: cannot serialize void field in a struct: " + name; 
+      break; 
+    case t_base_type::TYPE_STRING: 
+      if (type->is_binary()) { 
+        out << "binary (protocol, &data, &len"; 
+      } else { 
+        out << "string (protocol, &" << name; 
+      } 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      out << "bool (protocol, &" << name; 
+      break; 
+    case t_base_type::TYPE_I8: 
+      out << "byte (protocol, &" << name; 
+      break; 
+    case t_base_type::TYPE_I16: 
+      out << "i16 (protocol, &" << name; 
+      break; 
+    case t_base_type::TYPE_I32: 
+      out << "i32 (protocol, &" << name; 
+      break; 
+    case t_base_type::TYPE_I64: 
+      out << "i64 (protocol, &" << name; 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      out << "double (protocol, &" << name; 
+      break; 
+    default: 
+      throw "compiler error: no C reader for base type " + t_base_type::t_base_name(tbase) + name; 
+    } 
+    out << ", error)) < 0)" << endl; 
+    out << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" 
+        << endl; 
+ 
+    // load the byte array with the data 
+    if (tbase == t_base_type::TYPE_STRING && type->is_binary()) { 
+      indent(out) << name << " = g_byte_array_new();" << endl; 
+      indent(out) << "g_byte_array_append (" << name << ", (guint8 *) data, (guint) len);" << endl; 
+      indent(out) << "g_free (data);" << endl; 
+    } 
+  } else if (type->is_enum()) { 
+    string t = tmp("ecast"); 
+    out << indent() << "gint32 " << t << ";" << endl << indent() 
+        << "if ((ret = thrift_protocol_read_i32 (protocol, &" << t << ", error)) < 0)" << endl 
+        << indent() << "  return " << error_ret << ";" << endl << indent() << "xfer += ret;" << endl 
+        << indent() << name << " = (" << type_name(type) << ")" << t << ";" << endl; 
+  } else { 
+    throw std::logic_error("DO NOT KNOW HOW TO SERIALIZE FIELD '" + tfield->get_name() + "' TYPE '" 
+                           + type_name(type)); 
+  } 
+ 
+  // if the type is not required and this is a thrift struct (no prefix), 
+  // set the isset variable.  if the type is required, then set the 
+  // local variable indicating the value was set, so that we can do    // validation later. 
+  if (prefix != "" && tfield->get_req() != t_field::T_REQUIRED) { 
+    indent(out) << prefix << "__isset_" << tfield->get_name() << suffix << " = TRUE;" << endl; 
+  } else if (prefix != "" && tfield->get_req() == t_field::T_REQUIRED) { 
+    indent(out) << "isset_" << tfield->get_name() << " = TRUE;" << endl; 
+  } 
+} 
+ 
+void t_c_glib_generator::generate_deserialize_struct(ostream& out, 
+                                                     t_struct* tstruct, 
+                                                     string prefix, 
+                                                     int error_ret, 
+                                                     bool allocate) { 
+  string name_uc = to_upper_case(initial_caps_to_underscores(tstruct->get_name())); 
+  if (tstruct->is_xception()) { 
+    out << indent() << "/* This struct is an exception */" << endl; 
+    allocate = true; 
+  } 
+ 
+  if (allocate) { 
+    out << indent() << "if ( " << prefix << " != NULL)" << endl << indent() << "{" << endl; 
+    indent_up(); 
+    out << indent() << "g_object_unref (" << prefix << ");" << endl; 
+    indent_down(); 
+    out << indent() << "}" << endl << indent() << prefix << " = g_object_new (" << this->nspace_uc 
+        << "TYPE_" << name_uc << ", NULL);" << endl; 
+  } 
+  out << indent() << "if ((ret = thrift_struct_read (THRIFT_STRUCT (" << prefix 
+      << "), protocol, error)) < 0)" << endl << indent() << "{" << endl; 
+  indent_up(); 
+  if (allocate) { 
+    indent(out) << "g_object_unref (" << prefix << ");" << endl; 
+    if (tstruct->is_xception()) { 
+      indent(out) << prefix << " = NULL;" << endl; 
+    } 
+  } 
+  out << indent() << "return " << error_ret << ";" << endl; 
+  indent_down(); 
+  out << indent() << "}" << endl << indent() << "xfer += ret;" << endl; 
+} 
+ 
+void t_c_glib_generator::generate_deserialize_container(ostream& out, 
+                                                        t_type* ttype, 
+                                                        string prefix, 
+                                                        int error_ret) { 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    out << indent() << "guint32 size;" << endl 
+        << indent() << "guint32 i;" << endl 
+        << indent() << "ThriftType key_type;" << endl 
+        << indent() << "ThriftType value_type;" << endl 
+        << endl 
+        << indent() << "/* read the map begin marker */" << endl 
+        << indent() << "if ((ret = thrift_protocol_read_map_begin (protocol, " 
+           "&key_type, &value_type, &size, error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl 
+        << endl; 
+ 
+    // iterate over map elements 
+    out << indent() << "/* iterate through each of the map's fields */" << endl 
+        << indent() << "for (i = 0; i < size; i++)" << endl; 
+    scope_up(out); 
+    generate_deserialize_map_element(out, (t_map*)ttype, prefix, error_ret); 
+    scope_down(out); 
+    out << endl; 
+ 
+    // read map end 
+    out << indent() << "/* read the map end marker */" << endl 
+        << indent() << "if ((ret = thrift_protocol_read_map_end (protocol, " 
+           "error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl; 
+  } else if (ttype->is_set()) { 
+    out << indent() << "guint32 size;" << endl 
+        << indent() << "guint32 i;" << endl 
+        << indent() << "ThriftType element_type;" << endl 
+        << endl 
+        << indent() << "if ((ret = thrift_protocol_read_set_begin (protocol, " 
+           "&element_type, &size, error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl 
+        << endl; 
+ 
+    // iterate over the elements 
+    out << indent() << "/* iterate through the set elements */" << endl 
+        << indent() << "for (i = 0; i < size; ++i)" << endl; 
+    scope_up(out); 
+    generate_deserialize_set_element(out, (t_set*)ttype, prefix, error_ret); 
+    scope_down(out); 
+ 
+    // read set end 
+    out << indent() << "if ((ret = thrift_protocol_read_set_end (protocol, " 
+           "error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl 
+        << endl; 
+  } else if (ttype->is_list()) { 
+    out << indent() << "guint32 size;" << endl 
+        << indent() << "guint32 i;" << endl 
+        << indent() << "ThriftType element_type;" << endl 
+        << endl 
+        << indent() << "if ((ret = thrift_protocol_read_list_begin (protocol, " 
+           "&element_type,&size, error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl 
+        << endl; 
+ 
+    // iterate over the elements 
+    out << indent() << "/* iterate through list elements */" << endl 
+        << indent() << "for (i = 0; i < size; i++)" << endl; 
+    scope_up(out); 
+    generate_deserialize_list_element(out, 
+                                      (t_list*)ttype, 
+                                      prefix, 
+                                      "i", 
+                                      error_ret); 
+    scope_down(out); 
+ 
+    // read list end 
+    out << indent() << "if ((ret = thrift_protocol_read_list_end (protocol, " 
+           "error)) < 0)" << endl; 
+    indent_up(); 
+    out << indent() << "return " << error_ret << ";" << endl; 
+    indent_down(); 
+    out << indent() << "xfer += ret;" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+void t_c_glib_generator::declare_local_variable(ostream& out, t_type* ttype, string& name, bool for_hash_table) { 
+  string tname = type_name(ttype); 
+ 
+  /* If the given type is a typedef, find its underlying type so we 
+     can correctly determine how to generate a pointer to it */ 
+  ttype = get_true_type(ttype); 
+  string ptr = !is_numeric(ttype) ? "" : "*"; 
+ 
+  if (ttype->is_map()) { 
+    t_map* tmap = (t_map*)ttype; 
+    out << indent() << tname << ptr << " " << name << " = " 
+        << generate_new_hash_from_type(tmap->get_key_type(), tmap->get_val_type()) << endl; 
+  } else if (ttype->is_list()) { 
+    t_list* tlist = (t_list*)ttype; 
+    out << indent() << tname << ptr << " " << name << " = " 
+        << generate_new_array_from_type(tlist->get_elem_type()) << endl; 
+  } else if (for_hash_table && ttype->is_enum()) { 
+    out << indent() << tname << " " << name << ";" << endl; 
+  } else { 
+    out << indent() << tname << ptr << " " << name 
+        << (ptr != "" ? " = g_new (" + tname + ", 1)" : " = NULL") << ";" << endl; 
+  } 
+} 
+ 
+void t_c_glib_generator::declore_local_variable_for_write(ostream& out, 
+                                                          t_type* ttype, 
+                                                          string& name) { 
+  string tname = type_name(ttype); 
+  ttype = get_true_type(ttype); 
+  string ptr = ttype->is_string() || !ttype->is_base_type() ? " " : "* "; 
+  string init_val = ttype->is_enum() ? "" : " = NULL"; 
+  out << indent() << tname << ptr << name << init_val << ";" << endl; 
+} 
+ 
+void t_c_glib_generator::generate_deserialize_map_element(ostream& out, 
+                                                          t_map* tmap, 
+                                                          string prefix, 
+                                                          int error_ret) { 
+  t_type* tkey = tmap->get_key_type(); 
+  t_type* tval = tmap->get_val_type(); 
+  string keyname = tmp("key"); 
+  string valname = tmp("val"); 
+ 
+  declare_local_variable(out, tkey, keyname, true); 
+  declare_local_variable(out, tval, valname, true); 
+ 
+  /* If either the key or value type is a typedef, find its underlying 
+     type so we can correctly determine how to generate a pointer to 
+     it */ 
+  tkey = get_true_type(tkey); 
+  tval = get_true_type(tval); 
+ 
+  string tkey_ptr = tkey->is_string() || !tkey->is_base_type() ? "" : "*"; 
+  string tval_ptr = tval->is_string() || !tval->is_base_type() ? "" : "*"; 
+ 
+  // deserialize the fields of the map element 
+  t_field fkey(tkey, tkey_ptr + keyname); 
+  generate_deserialize_field(out, &fkey, "", "", error_ret); 
+  t_field fval(tval, tval_ptr + valname); 
+  generate_deserialize_field(out, &fval, "", "", error_ret); 
+ 
+  indent(out) << "if (" << prefix << " && " << keyname << ")" << endl; 
+  indent_up(); 
+  indent(out) << "g_hash_table_insert ((GHashTable *)" << prefix << ", (gpointer) " << keyname 
+              << ", (gpointer) " << valname << ");" << endl; 
+  indent_down(); 
+} 
+ 
+void t_c_glib_generator::generate_deserialize_set_element(ostream& out, 
+                                                          t_set* tset, 
+                                                          string prefix, 
+                                                          int error_ret) { 
+  t_type* telem = tset->get_elem_type(); 
+  string elem = tmp("_elem"); 
+  string telem_ptr = telem->is_string() || !telem->is_base_type() ? "" : "*"; 
+ 
+  declare_local_variable(out, telem, elem, true); 
+ 
+  t_field felem(telem, telem_ptr + elem); 
+  generate_deserialize_field(out, &felem, "", "", error_ret); 
+ 
+  indent(out) << "if (" << prefix << " && " << elem << ")" << endl; 
+  indent_up(); 
+  indent(out) << "g_hash_table_insert ((GHashTable *) " << prefix << ", (gpointer) " << elem 
+              << ", (gpointer) " << elem << ");" << endl; 
+  indent_down(); 
+} 
+ 
+void t_c_glib_generator::generate_deserialize_list_element(ostream& out, 
+                                                           t_list* tlist, 
+                                                           string prefix, 
+                                                           string index, 
+                                                           int error_ret) { 
+  (void)index; 
+  t_type* ttype = get_true_type(tlist->get_elem_type()); 
+  string elem = tmp("_elem"); 
+  string telem_ptr = !is_numeric(ttype) ? "" : "*"; 
+ 
+  declare_local_variable(out, ttype, elem, false); 
+ 
+  t_field felem(ttype, telem_ptr + elem); 
+  generate_deserialize_field(out, &felem, "", "", error_ret); 
+ 
+  if (ttype->is_void()) { 
+    throw std::runtime_error("compiler error: list element type cannot be void"); 
+  } else if (is_numeric(ttype)) { 
+    indent(out) << "g_array_append_vals (" << prefix << ", " << elem << ", 1);" << endl; 
+  } else { 
+    indent(out) << "g_ptr_array_add (" << prefix << ", " << elem << ");" << endl; 
+  } 
+} 
+ 
+string t_c_glib_generator::generate_free_func_from_type(t_type* ttype) { 
+  if (ttype == NULL) 
+    return "NULL"; 
+ 
+  if (ttype->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "compiler error: cannot determine hash type"; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+    case t_base_type::TYPE_I64: 
+    case t_base_type::TYPE_DOUBLE: 
+      return "g_free"; 
+    case t_base_type::TYPE_STRING: 
+      if (((t_base_type*)ttype)->is_binary()) { 
+        return "thrift_string_free"; 
+      } 
+      return "g_free"; 
+    default: 
+      throw "compiler error: no hash table info for type"; 
+    } 
+  } else if (ttype->is_enum()) { 
+    return "NULL"; 
+  } else if (ttype->is_map() || ttype->is_set()) { 
+    return "(GDestroyNotify) thrift_safe_hash_table_destroy"; 
+  } else if (ttype->is_struct()) { 
+    return "g_object_unref"; 
+  } else if (ttype->is_list()) { 
+    t_type* etype = ((t_list*)ttype)->get_elem_type(); 
+    if (etype->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)etype)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot determine array type"; 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+      case t_base_type::TYPE_I8: 
+      case t_base_type::TYPE_I16: 
+      case t_base_type::TYPE_I32: 
+      case t_base_type::TYPE_I64: 
+      case t_base_type::TYPE_DOUBLE: 
+        return "(GDestroyNotify) g_array_unref"; 
+      case t_base_type::TYPE_STRING: 
+        return "(GDestroyNotify) g_ptr_array_unref"; 
+      default: 
+        throw "compiler error: no array info for type"; 
+      } 
+    } else if (etype->is_container() || etype->is_struct()) { 
+      return "(GDestroyNotify) g_ptr_array_unref"; 
+      ; 
+    } else if (etype->is_enum()) { 
+      return "(GDestroyNotify) g_array_unref"; 
+    } 
+    printf("Type not expected inside the array: %s\n", etype->get_name().c_str()); 
+    throw "Type not expected inside array"; 
+  } else if (ttype->is_typedef()) { 
+    return generate_free_func_from_type(((t_typedef*)ttype)->get_type()); 
+  } 
+  printf("Type not expected: %s\n", ttype->get_name().c_str()); 
+  throw "Type not expected"; 
+} 
+ 
+string t_c_glib_generator::generate_hash_func_from_type(t_type* ttype) { 
+  if (ttype == NULL) 
+    return "NULL"; 
+ 
+  if (ttype->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "compiler error: cannot determine hash type"; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      return "thrift_boolean_hash"; 
+    case t_base_type::TYPE_I8: 
+      return "thrift_int8_hash"; 
+    case t_base_type::TYPE_I16: 
+      return "thrift_int16_hash"; 
+    case t_base_type::TYPE_I32: 
+      return "g_int_hash"; 
+    case t_base_type::TYPE_I64: 
+      return "g_int64_hash"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "g_double_hash"; 
+    case t_base_type::TYPE_STRING: 
+      return "g_str_hash"; 
+    default: 
+      throw "compiler error: no hash table info for type"; 
+    } 
+  } else if (ttype->is_enum()) { 
+    return "g_direct_hash"; 
+  } else if (ttype->is_container() || ttype->is_struct()) { 
+    return "g_direct_hash"; 
+  } else if (ttype->is_typedef()) { 
+    return generate_hash_func_from_type(((t_typedef*)ttype)->get_type()); 
+  } 
+  printf("Type not expected: %s\n", ttype->get_name().c_str()); 
+  throw "Type not expected"; 
+} 
+ 
+string t_c_glib_generator::generate_cmp_func_from_type(t_type* ttype) { 
+  if (ttype == NULL) 
+    return "NULL"; 
+ 
+  if (ttype->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "compiler error: cannot determine hash type"; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      return "thrift_boolean_equal"; 
+    case t_base_type::TYPE_I8: 
+      return "thrift_int8_equal"; 
+    case t_base_type::TYPE_I16: 
+      return "thrift_int16_equal"; 
+    case t_base_type::TYPE_I32: 
+      return "g_int_equal"; 
+    case t_base_type::TYPE_I64: 
+      return "g_int64_equal"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "g_double_equal"; 
+    case t_base_type::TYPE_STRING: 
+      return "g_str_equal"; 
+    default: 
+      throw "compiler error: no hash table info for type"; 
+    } 
+  } else if (ttype->is_enum()) { 
+    return "g_direct_equal"; 
+  } else if (ttype->is_container() || ttype->is_struct()) { 
+    return "g_direct_equal"; 
+  } else if (ttype->is_typedef()) { 
+    return generate_cmp_func_from_type(((t_typedef*)ttype)->get_type()); 
+  } 
+  printf("Type not expected: %s\n", ttype->get_name().c_str()); 
+  throw "Type not expected"; 
+} 
+ 
+string t_c_glib_generator::generate_new_hash_from_type(t_type* key, t_type* value) { 
+  string hash_func = generate_hash_func_from_type(key); 
+  string cmp_func = generate_cmp_func_from_type(key); 
+  string key_free_func = generate_free_func_from_type(key); 
+  string value_free_func = generate_free_func_from_type(value); 
+ 
+  return "g_hash_table_new_full (" + hash_func + ", " + cmp_func + ", " + key_free_func + ", " 
+         + value_free_func + ");"; 
+} 
+ 
+string t_c_glib_generator::generate_new_array_from_type(t_type* ttype) { 
+  if (ttype->is_void()) { 
+    throw std::runtime_error("compiler error: cannot determine array type"); 
+  } else if (is_numeric(ttype)) { 
+    return "g_array_new (0, 1, sizeof (" + base_type_name(ttype) + "));"; 
+  } else { 
+    string free_func = generate_free_func_from_type(ttype); 
+    return "g_ptr_array_new_with_free_func (" + free_func + ");"; 
+  } 
+} 
+ 
+/*************************************** 
+ * UTILITY FUNCTIONS                   * 
+ ***************************************/ 
+ 
+/** 
+ * Upper case a string.  Wraps boost's string utility. 
+ */ 
+string to_upper_case(string name) { 
+  string s(name); 
+  std::transform(s.begin(), s.end(), s.begin(), ::toupper); 
+  return s; 
+  //  return boost::to_upper_copy (name); 
+} 
+ 
+/** 
+ * Lower case a string.  Wraps boost's string utility. 
+ */ 
+string to_lower_case(string name) { 
+  string s(name); 
+  std::transform(s.begin(), s.end(), s.begin(), ::tolower); 
+  return s; 
+  //  return boost::to_lower_copy (name); 
+} 
+ 
+/** 
+ * Makes a string friendly to C code standards by lowercasing and adding 
+ * underscores, with the exception of the first character.  For example: 
+ * 
+ * Input: "ZomgCamelCase" 
+ * Output: "zomg_camel_case" 
+ */ 
+string initial_caps_to_underscores(string name) { 
+  string ret; 
+  const char* tmp = name.c_str(); 
+  int pos = 0; 
+ 
+  /* the first character isn't underscored if uppercase, just lowercased */ 
+  ret += tolower(tmp[pos]); 
+  pos++; 
+  for (unsigned int i = pos; i < name.length(); i++) { 
+    char lc = tolower(tmp[i]); 
+    if (lc != tmp[i]) { 
+      ret += '_'; 
+    } 
+    ret += lc; 
+  } 
+ 
+  return ret; 
+} 
+ 
+/** 
+ * Performs the reverse operation of initial_caps_to_underscores: The first 
+ * character of the string is made uppercase, along with each character that 
+ * follows an underscore (which is removed). Useful for converting Thrift 
+ * service-method names into GObject-style class names. 
+ * 
+ * Input: "zomg_camel_case" 
+ * Output: "ZomgCamelCase" 
+ */ 
+string underscores_to_initial_caps(string name) { 
+  string ret; 
+  const char* tmp = name.c_str(); 
+  bool uppercase_next = true; 
+ 
+  for (unsigned int i = 0; i < name.length(); i++) { 
+    char c = tmp[i]; 
+    if (c == '_') { 
+      uppercase_next = true; 
+    } else { 
+      if (uppercase_next) { 
+        ret += toupper(c); 
+        uppercase_next = false; 
+      } else { 
+        ret += c; 
+      } 
+    } 
+  } 
+ 
+  return ret; 
+} 
+ 
+/* register this generator with the main program */ 
+THRIFT_REGISTER_GENERATOR(c_glib, "C, using GLib", "") 

contrib/restricted/thrift/compiler/thrift/generate/t_cl_generator.cc

@@ -1,558 +1,558 @@
-/*
- * Copyright (c) 2008- Patrick Collison <patrick@collison.ie>
- * Copyright (c) 2006- Facebook
- *
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <string>
-#include <fstream>
-#include <iostream>
-#include <vector>
-
-#include <stdlib.h>
-#include <boost/tokenizer.hpp>
-#include <sys/stat.h>
-#include <sys/types.h>
-#include <sstream>
-#include <string>
-#include <algorithm>
-
-#include "thrift/platform.h"
-#include "t_oop_generator.h"
-using namespace std;
-
-
-/**
- * Common Lisp code generator.
- *
- * @author Patrick Collison <patrick@collison.ie>
- */
-class t_cl_generator : public t_oop_generator {
- public:
-  t_cl_generator(
-      t_program* program,
-      const std::map<std::string, std::string>& parsed_options,
-      const std::string& option_string)
-    : t_oop_generator(program)
-  {
-    no_asd = false;
-    system_prefix = "thrift-gen-";
-
-    std::map<std::string, std::string>::const_iterator iter;
-
-    for(iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
-      if(iter->first.compare("no_asd") == 0) {
-        no_asd = true;
-      } else if (iter->first.compare("sys_pref") == 0) {
-	system_prefix = iter->second;
-      } else {
-        throw "unknown option cl:" + iter->first;
-      }
-    }
-
-    out_dir_base_ = "gen-cl";
-    copy_options_ = option_string;
-  }
-
-  void init_generator();
-  void close_generator();
-
-  void generate_typedef     (t_typedef*  ttypedef);
-  void generate_enum        (t_enum*     tenum);
-  void generate_const       (t_const*    tconst);
-  void generate_struct      (t_struct*   tstruct);
-  void generate_xception    (t_struct*   txception);
-  void generate_service     (t_service*  tservice);
-  void generate_cl_struct (std::ostream& out, t_struct* tstruct, bool is_exception);
-  void generate_cl_struct_internal (std::ostream& out, t_struct* tstruct, bool is_exception);
-  void generate_exception_sig(std::ostream& out, t_function* f);
-  std::string render_const_value(t_type* type, t_const_value* value);
-
-  std::string cl_autogen_comment();
-  void asdf_def(std::ostream &out);
-  void package_def(std::ostream &out);
-  void package_in(std::ostream &out);
-  std::string generated_package();
-  std::string prefix(std::string name);
-  std::string package_of(t_program* program);
-  std::string package();
-  std::string render_includes();
-
-  std::string type_name(t_type* ttype);
-  std::string typespec (t_type *t);
-  std::string function_signature(t_function* tfunction);
-  std::string argument_list(t_struct* tstruct);
-
-  std::string cl_docstring(std::string raw);
-
- private:
-
-  int temporary_var;
-  /**
-   * Isolate the variable definitions, as they can require structure definitions
-   */
-  ofstream_with_content_based_conditional_update f_asd_;
-  ofstream_with_content_based_conditional_update f_types_;
-  ofstream_with_content_based_conditional_update f_vars_;
-
-  std::string copy_options_;
-
-  bool no_asd;
-  std::string system_prefix;
-};
-
-
-void t_cl_generator::init_generator() {
-  MKDIR(get_out_dir().c_str());
-  string program_dir = get_out_dir() + "/" + program_name_;
-  MKDIR(program_dir.c_str());
-
-  temporary_var = 0;
-
-  string f_types_name = program_dir + "/" + program_name_ + "-types.lisp";
-  string f_vars_name = program_dir + "/" + program_name_ + "-vars.lisp";
-
-  f_types_.open(f_types_name.c_str());
-  f_types_ << cl_autogen_comment() << endl;
-  f_vars_.open(f_vars_name.c_str());
-  f_vars_ << cl_autogen_comment() << endl;
-
-  package_def(f_types_);
-  package_in(f_types_);
-  package_in(f_vars_);
-
-  if (!no_asd) {
-    string f_asd_name = program_dir + "/" + system_prefix + program_name_ + ".asd";
-    f_asd_.open(f_asd_name.c_str());
-    f_asd_ << cl_autogen_comment() << endl;
-    asdf_def(f_asd_);
-  }
-}
-
-/**
- * Renders all the imports necessary for including another Thrift program
- */
-string t_cl_generator::render_includes() {
-  const vector<t_program*>& includes = program_->get_includes();
-  string result = "";
-  result += ":depends-on (:thrift";
-  for (size_t i = 0; i < includes.size(); ++i) {
-    result += " :" + system_prefix + underscore(includes[i]->get_name());
-  }
-  result += ")\n";
-  return result;
-}
-
-string t_cl_generator::package_of(t_program* program) {
-  string prefix = program->get_namespace("cl");
-  return prefix.empty() ? "thrift-generated" : prefix;
-}
-
-string t_cl_generator::package() {
-  return package_of(program_);
-}
-
-string t_cl_generator::prefix(string symbol) {
-  return "\"" + symbol + "\"";
-}
-
-string t_cl_generator::cl_autogen_comment() {
-  return
-    std::string(";;; ") + "Autogenerated by Thrift\n" +
-    ";;; DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING\n" +
-    ";;; options string: " + copy_options_ + "\n";
-}
-
-string t_cl_generator::cl_docstring(string raw) {
-  replace(raw.begin(), raw.end(), '"', '\'');
-  return raw;
-}
-
-
-void t_cl_generator::close_generator() {
-  f_asd_.close();
-  f_types_.close();
-  f_vars_.close();
-}
-
-string t_cl_generator::generated_package() {
-  return program_->get_namespace("cpp");
-}
-
-void t_cl_generator::asdf_def(std::ostream &out) {
-  out << "(asdf:defsystem #:" << system_prefix << program_name_ << endl;
-  indent_up();
-  out << indent() << render_includes()
-      << indent() << ":serial t" << endl
-      << indent() << ":components ("
-      << "(:file \"" << program_name_ << "-types\") "
-      << "(:file \"" << program_name_ << "-vars\")))" << endl;
-  indent_down();
-}
-
-/***
- * Generate a package definition. Add use references equivalent to the idl file's include statements.
- */
-void t_cl_generator::package_def(std::ostream &out) {
-  const vector<t_program*>& includes = program_->get_includes();
-
-  out << "(thrift:def-package :" << package();
-  if ( includes.size() > 0 ) {
-    out << " :use (";
-    for (size_t i = 0; i < includes.size(); ++i) {
-      out << " :" << includes[i]->get_name();
-    }
-    out << ")";
-  }
-  out << ")" << endl << endl;
-}
-
-void t_cl_generator::package_in(std::ostream &out) {
-  out << "(cl:in-package :" << package() << ")" << endl << endl;
-}
-
-/**
- * Generates a typedef. This is not done in Common Lisp, types are all implicit.
- *
- * @param ttypedef The type definition
- */
-void t_cl_generator::generate_typedef(t_typedef* ttypedef) {
-  (void)ttypedef;
-}
-
-void t_cl_generator::generate_enum(t_enum* tenum) {
-  f_types_ << "(thrift:def-enum " << prefix(tenum->get_name()) << endl;
-
-  vector<t_enum_value*> constants = tenum->get_constants();
-  vector<t_enum_value*>::iterator c_iter;
-  int value = -1;
-
-  indent_up();
-  f_types_ << indent() << "(";
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    value = (*c_iter)->get_value();
-
-    if(c_iter != constants.begin()) f_types_ << endl << indent() << " ";
-
-    f_types_ << "(\"" << (*c_iter)->get_name() << "\" . " << value << ")";
-  }
-  indent_down();
-  f_types_ << "))" << endl << endl;
-}
-
-/**
- * Generate a constant value
- */
-void t_cl_generator::generate_const(t_const* tconst) {
-  t_type* type = tconst->get_type();
-  string name = tconst->get_name();
-  t_const_value* value = tconst->get_value();
-
-  f_vars_ << "(thrift:def-constant " << prefix(name) << " " << render_const_value(type, value) << ")"
-          << endl << endl;
-}
-
-/**
- * Prints the value of a constant with the given type. Note that type checking
- * is NOT performed in this function as it is always run beforehand using the
- * validate_types method in main.cc
- */
-string t_cl_generator::render_const_value(t_type* type, t_const_value* value) {
-  type = get_true_type(type);
-  std::ostringstream out;
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      out << "\"" << value->get_string() << "\"";
-      break;
-    case t_base_type::TYPE_BOOL:
-      out << (value->get_integer() > 0 ? "t" : "nil");
-      break;
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-    case t_base_type::TYPE_I64:
-      out << value->get_integer();
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      if (value->get_type() == t_const_value::CV_INTEGER) {
-        out << value->get_integer();
-      } else {
-        out << value->get_double();
-      }
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else if (type->is_enum()) {
-    indent(out) << value->get_integer();
-  } else if (type->is_struct() || type->is_xception()) {
-    out << (type->is_struct() ? "(make-instance '" : "(make-exception '") <<
-           lowercase(type->get_name()) << " " << endl;
-    indent_up();
-
-    const vector<t_field*>& fields = ((t_struct*)type)->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      t_type* field_type = NULL;
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field_type = (*f_iter)->get_type();
-        }
-      }
-      if (field_type == NULL) {
-        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
-      }
-
-      out << indent() << ":" << v_iter->first->get_string() << " " <<
-        render_const_value(field_type, v_iter->second) << endl;
-    }
-    out << indent() << ")";
-
-    indent_down();
-  } else if (type->is_map()) {
-    // emit an hash form with both keys and values to be evaluated
-    t_type* ktype = ((t_map*)type)->get_key_type();
-    t_type* vtype = ((t_map*)type)->get_val_type();
-    out << "(thrift:map ";
-    indent_up();
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      out << endl << indent()
-          << "(cl:cons " << render_const_value(ktype, v_iter->first) << " "
-          << render_const_value(vtype, v_iter->second) << ")";
-    }
-    indent_down();
-    out << indent() << ")";
-  } else if (type->is_list() || type->is_set()) {
-    t_type* etype;
-    if (type->is_list()) {
-      etype = ((t_list*)type)->get_elem_type();
-    } else {
-      etype = ((t_set*)type)->get_elem_type();
-    }
-    if (type->is_set()) {
-      out << "(thrift:set" << endl;
-    } else {
-      out << "(thrift:list" << endl;
-    }
-    indent_up();
-    indent_up();
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      out << indent() << render_const_value(etype, *v_iter) << endl;
-    }
-    out << indent() << ")";
-    indent_down();
-    indent_down();
-  } else {
-    throw "CANNOT GENERATE CONSTANT FOR TYPE: " + type->get_name();
-  }
-  return out.str();
-}
-
-void t_cl_generator::generate_struct(t_struct* tstruct) {
-  generate_cl_struct(f_types_, tstruct, false);
-}
-
-void t_cl_generator::generate_xception(t_struct* txception) {
-  generate_cl_struct(f_types_, txception, true);
-}
-
-void t_cl_generator::generate_cl_struct_internal(std::ostream& out, t_struct* tstruct, bool is_exception) {
-  (void)is_exception;
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  out << "(";
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_const_value* value = (*m_iter)->get_value();
-    t_type* type = (*m_iter)->get_type();
-
-    if (m_iter != members.begin()) {
-      out << endl << indent() << " ";
-    }
-    out << "(" << prefix((*m_iter)->get_name()) << " " <<
-        ( (NULL != value) ? render_const_value(type, value) : "nil" ) <<
-        " :id " << (*m_iter)->get_key();
-    if ( type->is_base_type() && "string" == typespec(type) )
-      if ( ((t_base_type*)type)->is_binary() )
-        out << " :type binary";
-      else
-        out << " :type string";
-    else
-      out << " :type " << typespec(type);
-    if ( (*m_iter)->get_req() == t_field::T_OPTIONAL ) {
-      out << " :optional t";
-    }
-    if ( (*m_iter)->has_doc()) {
-      out << " :documentation \"" << cl_docstring((*m_iter)->get_doc()) << "\"";
-    }
-    out <<")";
-  }
-
-  out << ")";
-}
-
-void t_cl_generator::generate_cl_struct(std::ostream& out, t_struct* tstruct, bool is_exception = false) {
-  std::string name = type_name(tstruct);
-  out << (is_exception ? "(thrift:def-exception " : "(thrift:def-struct ") <<
-      prefix(name) << endl;
-  indent_up();
-  if ( tstruct->has_doc() ) {
-    out << indent() ;
-    out << "\"" << cl_docstring(tstruct->get_doc()) << "\"" << endl;
-  }
-  out << indent() ;
-  generate_cl_struct_internal(out, tstruct, is_exception);
-  indent_down();
-  out << ")" << endl << endl;
-}
-
-void t_cl_generator::generate_exception_sig(std::ostream& out, t_function* f) {
-  generate_cl_struct_internal(out, f->get_xceptions(), true);
-}
-
-void t_cl_generator::generate_service(t_service* tservice) {
-  string extends_client;
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-
-  if (tservice->get_extends() != NULL) {
-    extends_client = type_name(tservice->get_extends());
-  }
-
-  extends_client = extends_client.empty() ? "nil" : prefix(extends_client);
-
-  f_types_ << "(thrift:def-service " << prefix(service_name_) << " "
-           << extends_client;
-
-  indent_up();
-
-  if ( tservice->has_doc()) {
-      f_types_ << endl << indent()
-               << "(:documentation \"" << cl_docstring(tservice->get_doc()) << "\")";
-    }
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    t_function* function = *f_iter;
-    string fname = function->get_name();
-    string signature = function_signature(function);
-    t_struct* exceptions = function->get_xceptions();
-    const vector<t_field*>& xmembers = exceptions->get_members();
-
-    f_types_ << endl << indent() << "(:method " << prefix(fname);
-    f_types_ << " (" << signature << " "  << typespec((*f_iter)->get_returntype()) << ")";
-    if (xmembers.size() > 0) {
-      f_types_ << endl << indent() << " :exceptions " ;
-      generate_exception_sig(f_types_, function);
-    }
-    if ( (*f_iter)->is_oneway() ) {
-      f_types_ << endl << indent() << " :oneway t";
-    }
-    if ( (*f_iter)->has_doc() ) {
-      f_types_ << endl << indent() << " :documentation \""
-               << cl_docstring((*f_iter)->get_doc()) << "\"";
-  }
-    f_types_ << ")";
-  }
-
-  f_types_ << ")" << endl << endl;
-
-  indent_down();
-}
-
-string t_cl_generator::typespec(t_type *t) {
-  t = get_true_type(t);
-
-  if (t -> is_binary()){
-    return "binary";
-  } else if (t->is_base_type()) {
-    return type_name(t);
-  } else if (t->is_map()) {
-    t_map *m = (t_map*) t;
-    return "(thrift:map " + typespec(m->get_key_type()) + " " +
-      typespec(m->get_val_type()) + ")";
-  } else if (t->is_struct() || t->is_xception()) {
-    return "(struct " + prefix(type_name(t)) + ")";
-  } else if (t->is_list()) {
-    return "(thrift:list " + typespec(((t_list*) t)->get_elem_type()) + ")";
-  } else if (t->is_set()) {
-    return "(thrift:set " + typespec(((t_set*) t)->get_elem_type()) + ")";
-  } else if (t->is_enum()) {
-    return "(enum \"" + ((t_enum*) t)->get_name() + "\")";
-  } else {
-    throw "Sorry, I don't know how to generate this: " + type_name(t);
-  }
-}
-
-string t_cl_generator::function_signature(t_function* tfunction) {
-  return argument_list(tfunction->get_arglist());
-}
-
-string t_cl_generator::argument_list(t_struct* tstruct) {
-  stringstream res;
-  res << "(";
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      res << " ";
-    }
-    res << "(" + prefix((*f_iter)->get_name()) << " " <<
-      typespec((*f_iter)->get_type()) << " " <<
-      (*f_iter)->get_key() <<  ")";
-
-
-  }
-  res << ")";
-  return res.str();
-}
-
-string t_cl_generator::type_name(t_type* ttype) {
-  string prefix = "";
-  t_program* program = ttype->get_program();
-
-  if (program != NULL && program != program_)
-    prefix = package_of(program) == package() ? "" : package_of(program) + ":";
-
-  string name = ttype->get_name();
-
-  if (ttype->is_struct() || ttype->is_xception())
-    name = lowercase(ttype->get_name());
-
-  return prefix + name;
-}
-
-THRIFT_REGISTER_GENERATOR(
-    cl,
-    "Common Lisp",
-    "    no_asd:          Do not define ASDF systems for each generated Thrift program.\n"
-    "    sys_pref=        The prefix to give ASDF system names. Default: thrift-gen-\n")
+/* 
+ * Copyright (c) 2008- Patrick Collison <patrick@collison.ie> 
+ * Copyright (c) 2006- Facebook 
+ * 
+ * Licensed to the Apache Software Foundation (ASF) under one 
+ * or more contributor license agreements. See the NOTICE file 
+ * distributed with this work for additional information 
+ * regarding copyright ownership. The ASF licenses this file 
+ * to you under the Apache License, Version 2.0 (the 
+ * "License"); you may not use this file except in compliance 
+ * with the License. You may obtain a copy of the License at 
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, 
+ * software distributed under the License is distributed on an 
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
+ * KIND, either express or implied. See the License for the 
+ * specific language governing permissions and limitations 
+ * under the License. 
+ */ 
+ 
+#include <string> 
+#include <fstream> 
+#include <iostream> 
+#include <vector> 
+ 
+#include <stdlib.h> 
+#include <boost/tokenizer.hpp> 
+#include <sys/stat.h> 
+#include <sys/types.h> 
+#include <sstream> 
+#include <string> 
+#include <algorithm> 
+ 
+#include "thrift/platform.h" 
+#include "t_oop_generator.h" 
+using namespace std; 
+ 
+ 
+/** 
+ * Common Lisp code generator. 
+ * 
+ * @author Patrick Collison <patrick@collison.ie> 
+ */ 
+class t_cl_generator : public t_oop_generator { 
+ public: 
+  t_cl_generator( 
+      t_program* program, 
+      const std::map<std::string, std::string>& parsed_options, 
+      const std::string& option_string) 
+    : t_oop_generator(program) 
+  { 
+    no_asd = false; 
+    system_prefix = "thrift-gen-"; 
+ 
+    std::map<std::string, std::string>::const_iterator iter; 
+ 
+    for(iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) { 
+      if(iter->first.compare("no_asd") == 0) { 
+        no_asd = true; 
+      } else if (iter->first.compare("sys_pref") == 0) { 
+	system_prefix = iter->second; 
+      } else { 
+        throw "unknown option cl:" + iter->first; 
+      } 
+    } 
+ 
+    out_dir_base_ = "gen-cl"; 
+    copy_options_ = option_string; 
+  } 
+ 
+  void init_generator(); 
+  void close_generator(); 
+ 
+  void generate_typedef     (t_typedef*  ttypedef); 
+  void generate_enum        (t_enum*     tenum); 
+  void generate_const       (t_const*    tconst); 
+  void generate_struct      (t_struct*   tstruct); 
+  void generate_xception    (t_struct*   txception); 
+  void generate_service     (t_service*  tservice); 
+  void generate_cl_struct (std::ostream& out, t_struct* tstruct, bool is_exception); 
+  void generate_cl_struct_internal (std::ostream& out, t_struct* tstruct, bool is_exception); 
+  void generate_exception_sig(std::ostream& out, t_function* f); 
+  std::string render_const_value(t_type* type, t_const_value* value); 
+ 
+  std::string cl_autogen_comment(); 
+  void asdf_def(std::ostream &out); 
+  void package_def(std::ostream &out); 
+  void package_in(std::ostream &out); 
+  std::string generated_package(); 
+  std::string prefix(std::string name); 
+  std::string package_of(t_program* program); 
+  std::string package(); 
+  std::string render_includes(); 
+ 
+  std::string type_name(t_type* ttype); 
+  std::string typespec (t_type *t); 
+  std::string function_signature(t_function* tfunction); 
+  std::string argument_list(t_struct* tstruct); 
+ 
+  std::string cl_docstring(std::string raw); 
+ 
+ private: 
+ 
+  int temporary_var; 
+  /** 
+   * Isolate the variable definitions, as they can require structure definitions 
+   */ 
+  ofstream_with_content_based_conditional_update f_asd_; 
+  ofstream_with_content_based_conditional_update f_types_; 
+  ofstream_with_content_based_conditional_update f_vars_; 
+ 
+  std::string copy_options_; 
+ 
+  bool no_asd; 
+  std::string system_prefix; 
+}; 
+ 
+ 
+void t_cl_generator::init_generator() { 
+  MKDIR(get_out_dir().c_str()); 
+  string program_dir = get_out_dir() + "/" + program_name_; 
+  MKDIR(program_dir.c_str()); 
+ 
+  temporary_var = 0; 
+ 
+  string f_types_name = program_dir + "/" + program_name_ + "-types.lisp"; 
+  string f_vars_name = program_dir + "/" + program_name_ + "-vars.lisp"; 
+ 
+  f_types_.open(f_types_name.c_str()); 
+  f_types_ << cl_autogen_comment() << endl; 
+  f_vars_.open(f_vars_name.c_str()); 
+  f_vars_ << cl_autogen_comment() << endl; 
+ 
+  package_def(f_types_); 
+  package_in(f_types_); 
+  package_in(f_vars_); 
+ 
+  if (!no_asd) { 
+    string f_asd_name = program_dir + "/" + system_prefix + program_name_ + ".asd"; 
+    f_asd_.open(f_asd_name.c_str()); 
+    f_asd_ << cl_autogen_comment() << endl; 
+    asdf_def(f_asd_); 
+  } 
+} 
+ 
+/** 
+ * Renders all the imports necessary for including another Thrift program 
+ */ 
+string t_cl_generator::render_includes() { 
+  const vector<t_program*>& includes = program_->get_includes(); 
+  string result = ""; 
+  result += ":depends-on (:thrift"; 
+  for (size_t i = 0; i < includes.size(); ++i) { 
+    result += " :" + system_prefix + underscore(includes[i]->get_name()); 
+  } 
+  result += ")\n"; 
+  return result; 
+} 
+ 
+string t_cl_generator::package_of(t_program* program) { 
+  string prefix = program->get_namespace("cl"); 
+  return prefix.empty() ? "thrift-generated" : prefix; 
+} 
+ 
+string t_cl_generator::package() { 
+  return package_of(program_); 
+} 
+ 
+string t_cl_generator::prefix(string symbol) { 
+  return "\"" + symbol + "\""; 
+} 
+ 
+string t_cl_generator::cl_autogen_comment() { 
+  return 
+    std::string(";;; ") + "Autogenerated by Thrift\n" + 
+    ";;; DO NOT EDIT UNLESS YOU ARE SURE THAT YOU KNOW WHAT YOU ARE DOING\n" + 
+    ";;; options string: " + copy_options_ + "\n"; 
+} 
+ 
+string t_cl_generator::cl_docstring(string raw) { 
+  replace(raw.begin(), raw.end(), '"', '\''); 
+  return raw; 
+} 
+ 
+ 
+void t_cl_generator::close_generator() { 
+  f_asd_.close(); 
+  f_types_.close(); 
+  f_vars_.close(); 
+} 
+ 
+string t_cl_generator::generated_package() { 
+  return program_->get_namespace("cpp"); 
+} 
+ 
+void t_cl_generator::asdf_def(std::ostream &out) { 
+  out << "(asdf:defsystem #:" << system_prefix << program_name_ << endl; 
+  indent_up(); 
+  out << indent() << render_includes() 
+      << indent() << ":serial t" << endl 
+      << indent() << ":components (" 
+      << "(:file \"" << program_name_ << "-types\") " 
+      << "(:file \"" << program_name_ << "-vars\")))" << endl; 
+  indent_down(); 
+} 
+ 
+/*** 
+ * Generate a package definition. Add use references equivalent to the idl file's include statements. 
+ */ 
+void t_cl_generator::package_def(std::ostream &out) { 
+  const vector<t_program*>& includes = program_->get_includes(); 
+ 
+  out << "(thrift:def-package :" << package(); 
+  if ( includes.size() > 0 ) { 
+    out << " :use ("; 
+    for (size_t i = 0; i < includes.size(); ++i) { 
+      out << " :" << includes[i]->get_name(); 
+    } 
+    out << ")"; 
+  } 
+  out << ")" << endl << endl; 
+} 
+ 
+void t_cl_generator::package_in(std::ostream &out) { 
+  out << "(cl:in-package :" << package() << ")" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a typedef. This is not done in Common Lisp, types are all implicit. 
+ * 
+ * @param ttypedef The type definition 
+ */ 
+void t_cl_generator::generate_typedef(t_typedef* ttypedef) { 
+  (void)ttypedef; 
+} 
+ 
+void t_cl_generator::generate_enum(t_enum* tenum) { 
+  f_types_ << "(thrift:def-enum " << prefix(tenum->get_name()) << endl; 
+ 
+  vector<t_enum_value*> constants = tenum->get_constants(); 
+  vector<t_enum_value*>::iterator c_iter; 
+  int value = -1; 
+ 
+  indent_up(); 
+  f_types_ << indent() << "("; 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    value = (*c_iter)->get_value(); 
+ 
+    if(c_iter != constants.begin()) f_types_ << endl << indent() << " "; 
+ 
+    f_types_ << "(\"" << (*c_iter)->get_name() << "\" . " << value << ")"; 
+  } 
+  indent_down(); 
+  f_types_ << "))" << endl << endl; 
+} 
+ 
+/** 
+ * Generate a constant value 
+ */ 
+void t_cl_generator::generate_const(t_const* tconst) { 
+  t_type* type = tconst->get_type(); 
+  string name = tconst->get_name(); 
+  t_const_value* value = tconst->get_value(); 
+ 
+  f_vars_ << "(thrift:def-constant " << prefix(name) << " " << render_const_value(type, value) << ")" 
+          << endl << endl; 
+} 
+ 
+/** 
+ * Prints the value of a constant with the given type. Note that type checking 
+ * is NOT performed in this function as it is always run beforehand using the 
+ * validate_types method in main.cc 
+ */ 
+string t_cl_generator::render_const_value(t_type* type, t_const_value* value) { 
+  type = get_true_type(type); 
+  std::ostringstream out; 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      out << "\"" << value->get_string() << "\""; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      out << (value->get_integer() > 0 ? "t" : "nil"); 
+      break; 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+    case t_base_type::TYPE_I64: 
+      out << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      if (value->get_type() == t_const_value::CV_INTEGER) { 
+        out << value->get_integer(); 
+      } else { 
+        out << value->get_double(); 
+      } 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else if (type->is_enum()) { 
+    indent(out) << value->get_integer(); 
+  } else if (type->is_struct() || type->is_xception()) { 
+    out << (type->is_struct() ? "(make-instance '" : "(make-exception '") << 
+           lowercase(type->get_name()) << " " << endl; 
+    indent_up(); 
+ 
+    const vector<t_field*>& fields = ((t_struct*)type)->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+ 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      t_type* field_type = NULL; 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field_type = (*f_iter)->get_type(); 
+        } 
+      } 
+      if (field_type == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string(); 
+      } 
+ 
+      out << indent() << ":" << v_iter->first->get_string() << " " << 
+        render_const_value(field_type, v_iter->second) << endl; 
+    } 
+    out << indent() << ")"; 
+ 
+    indent_down(); 
+  } else if (type->is_map()) { 
+    // emit an hash form with both keys and values to be evaluated 
+    t_type* ktype = ((t_map*)type)->get_key_type(); 
+    t_type* vtype = ((t_map*)type)->get_val_type(); 
+    out << "(thrift:map "; 
+    indent_up(); 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      out << endl << indent() 
+          << "(cl:cons " << render_const_value(ktype, v_iter->first) << " " 
+          << render_const_value(vtype, v_iter->second) << ")"; 
+    } 
+    indent_down(); 
+    out << indent() << ")"; 
+  } else if (type->is_list() || type->is_set()) { 
+    t_type* etype; 
+    if (type->is_list()) { 
+      etype = ((t_list*)type)->get_elem_type(); 
+    } else { 
+      etype = ((t_set*)type)->get_elem_type(); 
+    } 
+    if (type->is_set()) { 
+      out << "(thrift:set" << endl; 
+    } else { 
+      out << "(thrift:list" << endl; 
+    } 
+    indent_up(); 
+    indent_up(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      out << indent() << render_const_value(etype, *v_iter) << endl; 
+    } 
+    out << indent() << ")"; 
+    indent_down(); 
+    indent_down(); 
+  } else { 
+    throw "CANNOT GENERATE CONSTANT FOR TYPE: " + type->get_name(); 
+  } 
+  return out.str(); 
+} 
+ 
+void t_cl_generator::generate_struct(t_struct* tstruct) { 
+  generate_cl_struct(f_types_, tstruct, false); 
+} 
+ 
+void t_cl_generator::generate_xception(t_struct* txception) { 
+  generate_cl_struct(f_types_, txception, true); 
+} 
+ 
+void t_cl_generator::generate_cl_struct_internal(std::ostream& out, t_struct* tstruct, bool is_exception) { 
+  (void)is_exception; 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  out << "("; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_const_value* value = (*m_iter)->get_value(); 
+    t_type* type = (*m_iter)->get_type(); 
+ 
+    if (m_iter != members.begin()) { 
+      out << endl << indent() << " "; 
+    } 
+    out << "(" << prefix((*m_iter)->get_name()) << " " << 
+        ( (NULL != value) ? render_const_value(type, value) : "nil" ) << 
+        " :id " << (*m_iter)->get_key(); 
+    if ( type->is_base_type() && "string" == typespec(type) ) 
+      if ( ((t_base_type*)type)->is_binary() ) 
+        out << " :type binary"; 
+      else 
+        out << " :type string"; 
+    else 
+      out << " :type " << typespec(type); 
+    if ( (*m_iter)->get_req() == t_field::T_OPTIONAL ) { 
+      out << " :optional t"; 
+    } 
+    if ( (*m_iter)->has_doc()) { 
+      out << " :documentation \"" << cl_docstring((*m_iter)->get_doc()) << "\""; 
+    } 
+    out <<")"; 
+  } 
+ 
+  out << ")"; 
+} 
+ 
+void t_cl_generator::generate_cl_struct(std::ostream& out, t_struct* tstruct, bool is_exception = false) { 
+  std::string name = type_name(tstruct); 
+  out << (is_exception ? "(thrift:def-exception " : "(thrift:def-struct ") << 
+      prefix(name) << endl; 
+  indent_up(); 
+  if ( tstruct->has_doc() ) { 
+    out << indent() ; 
+    out << "\"" << cl_docstring(tstruct->get_doc()) << "\"" << endl; 
+  } 
+  out << indent() ; 
+  generate_cl_struct_internal(out, tstruct, is_exception); 
+  indent_down(); 
+  out << ")" << endl << endl; 
+} 
+ 
+void t_cl_generator::generate_exception_sig(std::ostream& out, t_function* f) { 
+  generate_cl_struct_internal(out, f->get_xceptions(), true); 
+} 
+ 
+void t_cl_generator::generate_service(t_service* tservice) { 
+  string extends_client; 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+ 
+  if (tservice->get_extends() != NULL) { 
+    extends_client = type_name(tservice->get_extends()); 
+  } 
+ 
+  extends_client = extends_client.empty() ? "nil" : prefix(extends_client); 
+ 
+  f_types_ << "(thrift:def-service " << prefix(service_name_) << " " 
+           << extends_client; 
+ 
+  indent_up(); 
+ 
+  if ( tservice->has_doc()) { 
+      f_types_ << endl << indent() 
+               << "(:documentation \"" << cl_docstring(tservice->get_doc()) << "\")"; 
+    } 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    t_function* function = *f_iter; 
+    string fname = function->get_name(); 
+    string signature = function_signature(function); 
+    t_struct* exceptions = function->get_xceptions(); 
+    const vector<t_field*>& xmembers = exceptions->get_members(); 
+ 
+    f_types_ << endl << indent() << "(:method " << prefix(fname); 
+    f_types_ << " (" << signature << " "  << typespec((*f_iter)->get_returntype()) << ")"; 
+    if (xmembers.size() > 0) { 
+      f_types_ << endl << indent() << " :exceptions " ; 
+      generate_exception_sig(f_types_, function); 
+    } 
+    if ( (*f_iter)->is_oneway() ) { 
+      f_types_ << endl << indent() << " :oneway t"; 
+    } 
+    if ( (*f_iter)->has_doc() ) { 
+      f_types_ << endl << indent() << " :documentation \"" 
+               << cl_docstring((*f_iter)->get_doc()) << "\""; 
+  } 
+    f_types_ << ")"; 
+  } 
+ 
+  f_types_ << ")" << endl << endl; 
+ 
+  indent_down(); 
+} 
+ 
+string t_cl_generator::typespec(t_type *t) { 
+  t = get_true_type(t); 
+ 
+  if (t -> is_binary()){ 
+    return "binary"; 
+  } else if (t->is_base_type()) { 
+    return type_name(t); 
+  } else if (t->is_map()) { 
+    t_map *m = (t_map*) t; 
+    return "(thrift:map " + typespec(m->get_key_type()) + " " + 
+      typespec(m->get_val_type()) + ")"; 
+  } else if (t->is_struct() || t->is_xception()) { 
+    return "(struct " + prefix(type_name(t)) + ")"; 
+  } else if (t->is_list()) { 
+    return "(thrift:list " + typespec(((t_list*) t)->get_elem_type()) + ")"; 
+  } else if (t->is_set()) { 
+    return "(thrift:set " + typespec(((t_set*) t)->get_elem_type()) + ")"; 
+  } else if (t->is_enum()) { 
+    return "(enum \"" + ((t_enum*) t)->get_name() + "\")"; 
+  } else { 
+    throw "Sorry, I don't know how to generate this: " + type_name(t); 
+  } 
+} 
+ 
+string t_cl_generator::function_signature(t_function* tfunction) { 
+  return argument_list(tfunction->get_arglist()); 
+} 
+ 
+string t_cl_generator::argument_list(t_struct* tstruct) { 
+  stringstream res; 
+  res << "("; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      res << " "; 
+    } 
+    res << "(" + prefix((*f_iter)->get_name()) << " " << 
+      typespec((*f_iter)->get_type()) << " " << 
+      (*f_iter)->get_key() <<  ")"; 
+ 
+ 
+  } 
+  res << ")"; 
+  return res.str(); 
+} 
+ 
+string t_cl_generator::type_name(t_type* ttype) { 
+  string prefix = ""; 
+  t_program* program = ttype->get_program(); 
+ 
+  if (program != NULL && program != program_) 
+    prefix = package_of(program) == package() ? "" : package_of(program) + ":"; 
+ 
+  string name = ttype->get_name(); 
+ 
+  if (ttype->is_struct() || ttype->is_xception()) 
+    name = lowercase(ttype->get_name()); 
+ 
+  return prefix + name; 
+} 
+ 
+THRIFT_REGISTER_GENERATOR( 
+    cl, 
+    "Common Lisp", 
+    "    no_asd:          Do not define ASDF systems for each generated Thrift program.\n" 
+    "    sys_pref=        The prefix to give ASDF system names. Default: thrift-gen-\n") 

contrib/restricted/thrift/compiler/thrift/generate/t_cocoa_generator.cc

@@ -1,3309 +1,3309 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <string>
-#include <fstream>
-#include <iostream>
-#include <vector>
-
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sstream>
-#include "thrift/platform.h"
-#include "thrift/generate/t_oop_generator.h"
-
-using std::map;
-using std::ostream;
-using std::ofstream;
-using std::ostringstream;
-using std::string;
-using std::stringstream;
-using std::vector;
-
-static const string endl = "\n"; // avoid ostream << std::endl flushes
-
-/**
- * Objective-C code generator.
- *
- * mostly copy/pasting/tweaking from mcslee's work.
- */
-class t_cocoa_generator : public t_oop_generator {
-public:
-  t_cocoa_generator(t_program* program,
-                    const std::map<std::string, std::string>& parsed_options,
-                    const std::string& option_string)
-    : t_oop_generator(program) {
-    (void)option_string;
-    std::map<std::string, std::string>::const_iterator iter;
-
-    log_unexpected_ = false;
-    validate_required_ = false;
-    async_clients_ = false;
-    promise_kit_ = false;
-    debug_descriptions_ = false;
-    pods_ = false;
-    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
-      if( iter->first.compare("log_unexpected") == 0) {
-        log_unexpected_ = true;
-      } else if( iter->first.compare("validate_required") == 0) {
-        validate_required_ = true;
-      } else if( iter->first.compare("async_clients") == 0) {
-        async_clients_ = true;
-      } else if( iter->first.compare("promise_kit") == 0) {
-        promise_kit_ = true;
-      } else if( iter->first.compare("debug_descriptions") == 0) {
-        debug_descriptions_ = true;
-      } else if( iter->first.compare("pods") == 0) {
-        pods_ = true;
-      } else {
-        throw "unknown option cocoa:" + iter->first;
-      }
-    }
-
-    out_dir_base_ = "gen-cocoa";
-  }
-
-  /**
-   * Init and close methods
-   */
-
-  void init_generator();
-  void close_generator();
-
-  void generate_consts(std::vector<t_const*> consts);
-
-  /**
-   * Program-level generation functions
-   */
-
-  void generate_typedef(t_typedef* ttypedef);
-  void generate_enum(t_enum* tenum);
-  void generate_struct(t_struct* tstruct);
-  void generate_xception(t_struct* txception);
-  void generate_service(t_service* tservice);
-
-  void print_const_value(ostream& out,
-                         string name,
-                         t_type* type,
-                         t_const_value* value,
-                         bool defval = false);
-  std::string render_const_value(ostream& out,
-                                 t_type* type,
-                                 t_const_value* value,
-                                 bool box_it = false);
-
-  void generate_cocoa_struct(t_struct* tstruct, bool is_exception);
-  void generate_cocoa_struct_interface(std::ostream& out,
-                                       t_struct* tstruct,
-                                       bool is_xception = false);
-  void generate_cocoa_struct_implementation(std::ostream& out,
-                                            t_struct* tstruct,
-                                            bool is_xception = false,
-                                            bool is_result = false);
-  void generate_cocoa_struct_initializer_signature(std::ostream& out, t_struct* tstruct);
-  void generate_cocoa_struct_init_with_coder_method(ostream& out,
-                                                    t_struct* tstruct,
-                                                    bool is_exception);
-  void generate_cocoa_struct_encode_with_coder_method(ostream& out,
-                                                      t_struct* tstruct,
-                                                      bool is_exception);
-  void generate_cocoa_struct_copy_method(ostream& out,
-                                         t_struct* tstruct,
-                                         bool is_exception);
-  void generate_cocoa_struct_hash_method(ostream& out, t_struct* tstruct);
-  void generate_cocoa_struct_is_equal_method(ostream& out,
-                                             t_struct* tstruct,
-                                             bool is_exception);
-  void generate_cocoa_struct_field_accessor_implementations(std::ostream& out,
-                                                            t_struct* tstruct,
-                                                            bool is_exception);
-  void generate_cocoa_struct_reader(std::ostream& out, t_struct* tstruct);
-  void generate_cocoa_struct_result_writer(std::ostream& out, t_struct* tstruct);
-  void generate_cocoa_struct_writer(std::ostream& out, t_struct* tstruct);
-  void generate_cocoa_struct_validator(std::ostream& out, t_struct* tstruct);
-  void generate_cocoa_struct_description(std::ostream& out, t_struct* tstruct);
-
-  std::string function_result_helper_struct_type(t_service *tservice, t_function* tfunction);
-  std::string function_args_helper_struct_type(t_service* tservice, t_function* tfunction);
-  void generate_function_helpers(t_service *tservice, t_function* tfunction);
-
-  /**
-   * Service-level generation functions
-   */
-
-  void generate_cocoa_service_protocol(std::ostream& out, t_service* tservice);
-  void generate_cocoa_service_async_protocol(std::ostream& out, t_service* tservice);
-
-  void generate_cocoa_service_client_interface(std::ostream& out, t_service* tservice);
-  void generate_cocoa_service_client_async_interface(std::ostream& out, t_service* tservice);
-
-  void generate_cocoa_service_client_send_function_implementation(ostream& out,
-                                                                  t_service* tservice,
-                                                                  t_function* tfunction,
-                                                                  bool needs_protocol);
-  void generate_cocoa_service_client_send_function_invocation(ostream& out, t_function* tfunction);
-  void generate_cocoa_service_client_send_async_function_invocation(ostream& out,
-                                                                    t_function* tfunction,
-                                                                    string failureBlockName);
-  void generate_cocoa_service_client_recv_function_implementation(ostream& out,
-                                                                  t_service* tservice,
-                                                                  t_function* tfunction,
-                                                                  bool needs_protocol);
-  void generate_cocoa_service_client_implementation(std::ostream& out, t_service* tservice);
-  void generate_cocoa_service_client_async_implementation(std::ostream& out, t_service* tservice);
-
-  void generate_cocoa_service_server_interface(std::ostream& out, t_service* tservice);
-  void generate_cocoa_service_server_implementation(std::ostream& out, t_service* tservice);
-  void generate_cocoa_service_helpers(t_service* tservice);
-  void generate_service_client(t_service* tservice);
-  void generate_service_server(t_service* tservice);
-  void generate_process_function(t_service* tservice, t_function* tfunction);
-
-  /**
-   * Serialization constructs
-   */
-
-  void generate_deserialize_field(std::ostream& out, t_field* tfield, std::string fieldName);
-
-  void generate_deserialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = "");
-
-  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-
-  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = "");
-
-  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = "");
-
-  void generate_deserialize_list_element(std::ostream& out,
-                                         t_list* tlist,
-                                         std::string prefix = "");
-
-  void generate_serialize_field(std::ostream& out, t_field* tfield, std::string prefix = "");
-
-  void generate_serialize_struct(std::ostream& out, t_struct* tstruct, std::string fieldName = "");
-
-  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-
-  void generate_serialize_map_element(std::ostream& out,
-                                      t_map* tmap,
-                                      std::string iter,
-                                      std::string map);
-
-  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter);
-
-  void generate_serialize_list_element(std::ostream& out,
-                                       t_list* tlist,
-                                       std::string index,
-                                       std::string listName);
-
-  /**
-   * Helper rendering functions
-   */
-
-  std::string cocoa_prefix();
-  std::string cocoa_imports();
-  std::string cocoa_thrift_imports();
-  std::string type_name(t_type* ttype, bool class_ref = false, bool needs_mutable = false);
-  std::string element_type_name(t_type* ttype);
-  std::string base_type_name(t_base_type* tbase);
-  std::string declare_property(t_field* tfield);
-  std::string declare_property_isset(t_field* tfield);
-  std::string declare_property_unset(t_field* tfield);
-  std::string invalid_return_statement(t_function* tfunction);
-  std::string function_signature(t_function* tfunction, bool include_error);
-  std::string async_function_signature(t_function* tfunction, bool include_error);
-  std::string promise_function_signature(t_function* tfunction);
-  std::string argument_list(t_struct* tstruct, string protocol_name, bool include_error);
-  std::string type_to_enum(t_type* ttype);
-  std::string format_string_for_type(t_type* type);
-  std::string format_cast_for_type(t_type* type);
-  std::string call_field_setter(t_field* tfield, std::string fieldName);
-  std::string box(t_type *ttype, std::string field_name);
-  std::string unbox(t_type* ttype, std::string field_name);
-  std::string getter_name(string field_name);
-  std::string setter_name(string field_name);
-
-  bool type_can_be_copy(t_type* ttype) {
-    ttype = get_true_type(ttype);
-    
-    return ttype->is_string();
-  }
-  
-  bool type_can_be_null(t_type* ttype) {
-    ttype = get_true_type(ttype);
-
-    return ttype->is_container() || ttype->is_struct() || ttype->is_xception()
-           || ttype->is_string();
-  }
-
-private:
-  std::string cocoa_prefix_;
-  std::string constants_declarations_;
-  int error_constant_;
-
-  /**
-   * File streams
-   */
-
-  ofstream_with_content_based_conditional_update f_header_;
-  ofstream_with_content_based_conditional_update f_impl_;
-
-  bool log_unexpected_;
-  bool validate_required_;
-  bool async_clients_;
-  bool promise_kit_;
-  bool debug_descriptions_;
-  bool pods_;
-};
-
-/**
- * Prepares for file generation by opening up the necessary file output
- * streams.
- */
-void t_cocoa_generator::init_generator() {
-  // Make output directory
-  MKDIR(get_out_dir().c_str());
-  cocoa_prefix_ = program_->get_namespace("cocoa");
-
-  // we have a .h header file...
-  string f_header_name = cocoa_prefix_ + capitalize(program_name_) + ".h";
-  string f_header_fullname = get_out_dir() + f_header_name;
-  f_header_.open(f_header_fullname.c_str());
-
-  f_header_ << autogen_comment() << endl;
-
-  f_header_ << cocoa_imports() << cocoa_thrift_imports();
-
-  // ...and a .m implementation file
-  string f_impl_name = cocoa_prefix_ + capitalize(program_name_) + ".m";
-  string f_impl_fullname = get_out_dir() + f_impl_name;
-  f_impl_.open(f_impl_fullname.c_str());
-
-  f_impl_ << autogen_comment() << endl;
-
-  f_impl_ << cocoa_imports() << cocoa_thrift_imports() << "#import \"" << f_header_name << "\""
-          << endl << endl;
-
-  error_constant_ = 60000;
-}
-
-/**
- * Prints standard Cocoa imports
- *
- * @return List of imports for Cocoa libraries
- */
-string t_cocoa_generator::cocoa_imports() {
-  return string() + "#import <Foundation/Foundation.h>\n" + "\n";
-}
-
-/**
- * Prints thrift runtime imports
- *
- * @return List of imports necessary for thrift runtime
- */
-string t_cocoa_generator::cocoa_thrift_imports() {
-
-  vector<string> includes_list;
-  includes_list.push_back("TProtocol.h");
-  includes_list.push_back("TProtocolFactory.h");
-  includes_list.push_back("TApplicationError.h");
-  includes_list.push_back("TProtocolError.h");
-  includes_list.push_back("TProtocolUtil.h");
-  includes_list.push_back("TProcessor.h");
-  includes_list.push_back("TBase.h");
-  includes_list.push_back("TAsyncTransport.h");
-  includes_list.push_back("TBaseClient.h");
-
-  std::ostringstream includes;
-
-  vector<string>::const_iterator i_iter;
-  for (i_iter=includes_list.begin(); i_iter!=includes_list.end(); ++i_iter) {
-    includes << "#import ";
-    if (pods_) {
-      includes << "<Thrift/" << *i_iter << ">";
-    } else {
-      includes << "\"" << *i_iter << "\"";
-    }
-    includes << endl;
-  }
-
-  includes << endl;
-
-  if (promise_kit_) {
-    includes << "#import ";
-    if (pods_) {
-      includes << "<PromiseKit/PromiseKit.h>";
-    } else {
-      includes << "\"PromiseKit.h\"";
-    }
-    includes << endl;
-  }
-
-  // Include other Thrift includes
-  const vector<t_program*>& other_includes = program_->get_includes();
-  for (size_t i = 0; i < other_includes.size(); ++i) {
-    includes << "#import \""
-             << other_includes[i]->get_namespace("cocoa")
-             << capitalize(other_includes[i]->get_name())
-             << ".h\"" << endl;
-  }
-
-  includes << endl;
-
-  return includes.str();
-}
-
-/**
- * Finish up generation.
- */
-void t_cocoa_generator::close_generator() {
-  // stick our constants declarations at the end of the header file
-  // since they refer to things we are defining.
-  f_header_ << constants_declarations_ << endl;
-}
-
-/**
- * Generates a typedef. This is just a simple 1-liner in objective-c
- *
- * @param ttypedef The type definition
- */
-void t_cocoa_generator::generate_typedef(t_typedef* ttypedef) {
-  if (ttypedef->get_type()->is_map()) {
-    t_map *map = (t_map *)ttypedef->get_type();
-    if (map->get_key_type()->is_struct()) {
-      f_header_ << indent() << "@class " << type_name(map->get_key_type(), true) << ";" << endl;
-    }
-    if (map->get_val_type()->is_struct()) {
-      f_header_ << indent() << "@class " << type_name(map->get_val_type(), true) << ";" << endl;
-    }
-  }
-  else if (ttypedef->get_type()->is_set()) {
-    t_set *set = (t_set *)ttypedef->get_type();
-    if (set->get_elem_type()->is_struct()) {
-      f_header_ << indent() << "@class " << type_name(set->get_elem_type(), true) << ";" << endl;
-    }
-  }
-  else if (ttypedef->get_type()->is_list()) {
-    t_list *list = (t_list *)ttypedef->get_type();
-    if (list->get_elem_type()->is_struct()) {
-      f_header_ << indent() << "@class " << type_name(list->get_elem_type(), true) << ";" << endl;
-    }
-  }
-  f_header_ << indent() << "typedef " << type_name(ttypedef->get_type()) << " " << cocoa_prefix_
-            << ttypedef->get_symbolic() << ";" << endl << endl;
-  if (ttypedef->get_type()->is_container()) {
-    f_header_ << indent() << "typedef " << type_name(ttypedef->get_type(), false, true) << " " << cocoa_prefix_
-              << "Mutable" << ttypedef->get_symbolic() << ";" << endl << endl;
-  }
-}
-
-/**
- * Generates code for an enumerated type. In Objective-C, this is
- * essentially the same as the thrift definition itself, instead using
- * NS_ENUM keyword in Objective-C.  For namespace purposes, the name of
- * the enum is prefixed to each element in keeping with Cocoa & Swift
- * standards.
- *
- * @param tenum The enumeration
- */
-void t_cocoa_generator::generate_enum(t_enum* tenum) {
-  f_header_ << indent() << "typedef NS_ENUM(SInt32, " << cocoa_prefix_ << tenum->get_name() << ") {" << endl;
-  indent_up();
-
-  vector<t_enum_value*> constants = tenum->get_constants();
-  vector<t_enum_value*>::iterator c_iter;
-  bool first = true;
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    if (first) {
-      first = false;
-    } else {
-      f_header_ << "," << endl;
-    }
-    f_header_ << indent() << cocoa_prefix_ << tenum->get_name() << (*c_iter)->get_name();
-    f_header_ << " = " << (*c_iter)->get_value();
-  }
-
-  indent_down();
-  f_header_ << endl << "};" << endl << endl;
-}
-
-/**
- * Generates a class that holds all the constants.
- */
-void t_cocoa_generator::generate_consts(std::vector<t_const*> consts) {
-  std::ostringstream const_interface;
-
-  const_interface << "FOUNDATION_EXPORT NSString *" << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain;" << endl
-                  << endl;
-
-
-  bool needs_class = false;
-
-  // Public constants for base types & strings
-  vector<t_const*>::iterator c_iter;
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    t_type* type = (*c_iter)->get_type()->get_true_type();
-    if (!type->is_container() && !type->is_struct()) {
-      const_interface << "FOUNDATION_EXPORT " << type_name(type) << " "
-                      << cocoa_prefix_ << capitalize((*c_iter)->get_name()) << ";" << endl;
-    }
-    else {
-      needs_class = true;
-    }
-  }
-
-
-  string constants_class_name = cocoa_prefix_ + capitalize(program_name_) + "Constants";
-
-  if (needs_class) {
-
-    const_interface << endl;
-
-    const_interface << "@interface " << constants_class_name << " : NSObject ";
-    scope_up(const_interface);
-    scope_down(const_interface);
-
-    // getter method for each constant defined.
-    for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-      string name = (*c_iter)->get_name();
-      t_type* type = (*c_iter)->get_type()->get_true_type();
-      if (type->is_container() || type->is_struct()) {
-        t_type* type = (*c_iter)->get_type();
-        const_interface << endl << "+ (" << type_name(type) << ") " << name << ";" << endl;
-      }
-    }
-
-    const_interface << endl << "@end";
-  }
-
-  // this gets spit into the header file in ::close_generator
-  constants_declarations_ = const_interface.str();
-
-  f_impl_ << "NSString *" << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain = "
-          << "@\"" << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain\";" << endl << endl;
-
-  // variables in the .m hold all simple constant values
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    string name = (*c_iter)->get_name();
-    t_type* type = (*c_iter)->get_type();
-    f_impl_ << type_name(type) << " " << cocoa_prefix_ << name;
-    t_type* ttype = type->get_true_type();
-    if (!ttype->is_container() && !ttype->is_struct()) {
-      f_impl_ << " = " << render_const_value(f_impl_, type, (*c_iter)->get_value());
-    }
-    f_impl_ << ";" << endl;
-  }
-  f_impl_ << endl;
-
-  if (needs_class) {
-
-    f_impl_ << "@implementation " << constants_class_name << endl << endl;
-
-    // initialize complex constants when the class is loaded
-    f_impl_ << "+ (void) initialize ";
-    scope_up(f_impl_);
-
-    for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-      t_type* ttype = (*c_iter)->get_type()->get_true_type();
-      if (ttype->is_container() || ttype->is_struct()) {
-        f_impl_ << endl;
-        print_const_value(f_impl_,
-                          cocoa_prefix_ + (*c_iter)->get_name(),
-                          (*c_iter)->get_type(),
-                          (*c_iter)->get_value(),
-                          false);
-        f_impl_ << ";" << endl;
-      }
-    }
-    scope_down(f_impl_);
-
-    // getter method for each constant
-    for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-      string name = (*c_iter)->get_name();
-      t_type* type = (*c_iter)->get_type()->get_true_type();
-      if (type->is_container() || type->is_struct()) {
-        f_impl_ << endl << "+ (" << type_name(type) << ") " << name << " ";
-        scope_up(f_impl_);
-        indent(f_impl_) << "return " << cocoa_prefix_ << name << ";" << endl;
-        scope_down(f_impl_);
-      }
-    }
-
-    f_impl_ << "@end" << endl << endl;
-  }
-}
-
-/**
- * Generates a struct definition for a thrift data type. This is a class
- * with protected data members, read(), write(), and getters and setters.
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_struct(t_struct* tstruct) {
-  generate_cocoa_struct_interface(f_header_, tstruct, false);
-  generate_cocoa_struct_implementation(f_impl_, tstruct, false);
-}
-
-/**
- * Exceptions are structs, but they inherit from NSException
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_xception(t_struct* txception) {
-  generate_cocoa_struct_interface(f_header_, txception, true);
-  generate_cocoa_struct_implementation(f_impl_, txception, true);
-}
-
-/**
- * Generate the interface for a struct
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_cocoa_struct_interface(ostream& out,
-                                                        t_struct* tstruct,
-                                                        bool is_exception) {
-
-  if (is_exception) {
-    out << "enum {" << endl
-        << "  " << cocoa_prefix_ << capitalize(program_name_) << "Error" << tstruct->get_name() <<  " = -" << error_constant_++ << endl
-        << "};" << endl
-        << endl;
-  }
-
-  out << "@interface " << cocoa_prefix_ << tstruct->get_name() << " : ";
-
-  if (is_exception) {
-    out << "NSError ";
-  } else {
-    out << "NSObject ";
-  }
-  out << "<TBase, NSCoding, NSCopying> " << endl;
-
-  out << endl;
-
-  // properties
-  const vector<t_field*>& members = tstruct->get_members();
-  if (members.size() > 0) {
-    vector<t_field*>::const_iterator m_iter;
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      out << indent() << declare_property(*m_iter) << endl;
-      out << indent() << declare_property_isset(*m_iter) << endl;
-      out << indent() << declare_property_unset(*m_iter) << endl;
-      out << endl;
-    }
-  }
-
-  out << endl;
-
-  // initializer for all fields
-  if (!members.empty()) {
-    generate_cocoa_struct_initializer_signature(out, tstruct);
-    out << ";" << endl;
-  }
-  out << endl;
-
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generate signature for initializer of struct with a parameter for
- * each field.
- */
-void t_cocoa_generator::generate_cocoa_struct_initializer_signature(ostream& out,
-                                                                    t_struct* tstruct) {
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-  indent(out) << "- (instancetype) initWith";
-  for (m_iter = members.begin(); m_iter != members.end();) {
-    if (m_iter == members.begin()) {
-      out << capitalize((*m_iter)->get_name());
-    } else {
-      out << (*m_iter)->get_name();
-    }
-    out << ": (" << type_name((*m_iter)->get_type()) << ") " << (*m_iter)->get_name();
-    ++m_iter;
-    if (m_iter != members.end()) {
-      out << " ";
-    }
-  }
-}
-
-/**
- * Generate the initWithCoder method for this struct so it's compatible with
- * the NSCoding protocol
- */
-void t_cocoa_generator::generate_cocoa_struct_init_with_coder_method(ostream& out,
-                                                                     t_struct* tstruct,
-                                                                     bool is_exception) {
-
-  indent(out) << "- (instancetype) initWithCoder: (NSCoder *) decoder" << endl;
-  scope_up(out);
-
-  if (is_exception) {
-    // NSExceptions conform to NSCoding, so we can call super
-    indent(out) << "self = [super initWithCoder: decoder];" << endl;
-  } else {
-    indent(out) << "self = [super init];" << endl;
-  }
-
-  indent(out) << "if (self) ";
-  scope_up(out);
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = get_true_type((*m_iter)->get_type());
-    out << indent() << "if ([decoder containsValueForKey: @\"" << (*m_iter)->get_name() << "\"])"
-        << endl;
-    scope_up(out);
-    out << indent() << "_" << (*m_iter)->get_name() << " = ";
-    if (type_can_be_null(t)) {
-      out << "[decoder decodeObjectForKey: @\"" << (*m_iter)->get_name() << "\"];"
-          << endl;
-    } else if (t->is_enum()) {
-      out << "[decoder decodeIntForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl;
-    } else {
-      t_base_type::t_base tbase = ((t_base_type*)t)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_BOOL:
-        out << "[decoder decodeBoolForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I8:
-        out << "[decoder decodeIntForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I16:
-        out << "[decoder decodeIntForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I32:
-        out << "[decoder decodeInt32ForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I64:
-        out << "[decoder decodeInt64ForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "[decoder decodeDoubleForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      default:
-        throw "compiler error: don't know how to decode thrift type: "
-            + t_base_type::t_base_name(tbase);
-      }
-    }
-    out << indent() << "_" << (*m_iter)->get_name() << "IsSet = YES;" << endl;
-    scope_down(out);
-  }
-
-  scope_down(out);
-
-  out << indent() << "return self;" << endl;
-  scope_down(out);
-  out << endl;
-}
-
-/**
- * Generate the encodeWithCoder method for this struct so it's compatible with
- * the NSCoding protocol
- */
-void t_cocoa_generator::generate_cocoa_struct_encode_with_coder_method(ostream& out,
-                                                                       t_struct* tstruct,
-                                                                       bool is_exception) {
-
-  indent(out) << "- (void) encodeWithCoder: (NSCoder *) encoder" << endl;
-  scope_up(out);
-
-  if (is_exception) {
-    // NSExceptions conform to NSCoding, so we can call super
-    out << indent() << "[super encodeWithCoder: encoder];" << endl;
-  }
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = get_true_type((*m_iter)->get_type());
-    out << indent() << "if (_" << (*m_iter)->get_name() << "IsSet)" << endl;
-    scope_up(out);
-    if (type_can_be_null(t)) {
-      out << indent() << "[encoder encodeObject: _" << (*m_iter)->get_name() << " forKey: @\""
-          << (*m_iter)->get_name() << "\"];" << endl;
-    } else if (t->is_enum()) {
-      out << indent() << "[encoder encodeInt: _" << (*m_iter)->get_name() << " forKey: @\""
-          << (*m_iter)->get_name() << "\"];" << endl;
-    } else {
-      t_base_type::t_base tbase = ((t_base_type*)t)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_BOOL:
-        out << indent() << "[encoder encodeBool: _" << (*m_iter)->get_name() << " forKey: @\""
-            << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I8:
-        out << indent() << "[encoder encodeInt: _" << (*m_iter)->get_name() << " forKey: @\""
-            << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I16:
-        out << indent() << "[encoder encodeInt: _" << (*m_iter)->get_name() << " forKey: @\""
-            << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I32:
-        out << indent() << "[encoder encodeInt32: _" << (*m_iter)->get_name() << " forKey: @\""
-            << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_I64:
-        out << indent() << "[encoder encodeInt64: _" << (*m_iter)->get_name() << " forKey: @\""
-            << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << indent() << "[encoder encodeDouble: _" << (*m_iter)->get_name() << " forKey: @\""
-            << (*m_iter)->get_name() << "\"];" << endl;
-        break;
-      default:
-        throw "compiler error: don't know how to encode thrift type: "
-            + t_base_type::t_base_name(tbase);
-      }
-    }
-    scope_down(out);
-  }
-
-  scope_down(out);
-  out << endl;
-}
-
-/**
- * Generate the copy method for this struct
- */
-void t_cocoa_generator::generate_cocoa_struct_copy_method(ostream& out, t_struct* tstruct, bool is_exception) {
-  out << indent() << "- (instancetype) copyWithZone:(NSZone *)zone" << endl;
-  scope_up(out);
-
-  if (is_exception) {
-    out << indent() << type_name(tstruct) << " val = [" << cocoa_prefix_ << tstruct->get_name() << " errorWithDomain: self.domain code: self.code userInfo: self.userInfo];" << endl;
-  } else {
-    out << indent() << type_name(tstruct) << " val = [" << cocoa_prefix_ << tstruct->get_name() << " new];" << endl;
-  }
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = get_true_type((*m_iter)->get_type());
-    out << indent() << "if (_" << (*m_iter)->get_name() << "IsSet)" << endl;
-    scope_up(out);
-    if (type_can_be_null(t)) {
-      out << indent() << "val." << (*m_iter)->get_name() << " = [self." << (*m_iter)->get_name() << " copy];";
-    } else {
-      out << indent() << "val." << (*m_iter)->get_name() << " = self." << (*m_iter)->get_name() << ";";
-    }
-    out << endl;
-    scope_down(out);
-  }
-
-  out << indent() << "return val;" << endl;
-
-  scope_down(out);
-  out << endl;
-}
-
-/**
- * Generate the hash method for this struct
- */
-void t_cocoa_generator::generate_cocoa_struct_hash_method(ostream& out, t_struct* tstruct) {
-  indent(out) << "- (NSUInteger) hash" << endl;
-  scope_up(out);
-  out << indent() << "NSUInteger hash = 17;" << endl;
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = get_true_type((*m_iter)->get_type());
-    out << indent() << "hash = (hash * 31) ^ _" << (*m_iter)->get_name()
-        << "IsSet ? 2654435761 : 0;" << endl;
-    out << indent() << "if (_" << (*m_iter)->get_name() << "IsSet)" << endl;
-    scope_up(out);
-    if (type_can_be_null(t)) {
-      out << indent() << "hash = (hash * 31) ^ [_" << (*m_iter)->get_name() << " hash];" << endl;
-    } else {
-      out << indent() << "hash = (hash * 31) ^ [@(_" << (*m_iter)->get_name() << ") hash];"
-          << endl;
-    }
-    scope_down(out);
-  }
-
-  out << indent() << "return hash;" << endl;
-  scope_down(out);
-  out << endl;
-}
-
-/**
- * Generate the isEqual method for this struct
- */
-void t_cocoa_generator::generate_cocoa_struct_is_equal_method(ostream& out, t_struct* tstruct, bool is_exception) {
-  indent(out) << "- (BOOL) isEqual: (id) anObject" << endl;
-  scope_up(out);
-
-  indent(out) << "if (self == anObject) {" << endl;
-  indent_up();
-  indent(out) << "return YES;" << endl;
-  indent_down();
-  indent(out) << "}" << endl;
-
-  string class_name = cocoa_prefix_ + tstruct->get_name();
-
-  if (is_exception) {
-    indent(out) << "if (![super isEqual:anObject]) {" << endl;
-    indent_up();
-    indent(out) << "return NO;" << endl;
-    indent_down();
-    indent(out) << "}" << endl << endl;
-  }
-  else {
-    indent(out) << "if (![anObject isKindOfClass:[" << class_name << " class]]) {" << endl;
-    indent_up();
-    indent(out) << "return NO;" << endl;
-    indent_down();
-    indent(out) << "}" << endl;
-  }
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  if (!members.empty()) {
-    indent(out) << class_name << " *other = (" << class_name << " *)anObject;" << endl;
-
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      t_type* t = get_true_type((*m_iter)->get_type());
-      string name = (*m_iter)->get_name();
-      if (type_can_be_null(t)) {
-        out << indent() << "if ((_" << name << "IsSet != other->_" << name << "IsSet) ||" << endl
-            << indent() << "    "
-            << "(_" << name << "IsSet && "
-            << "((_" << name << " || other->_" << name << ") && "
-            << "![_" << name << " isEqual:other->_" << name << "]))) {" << endl;
-      } else {
-        out << indent() << "if ((_" << name << "IsSet != other->_" << name << "IsSet) ||" << endl
-            << indent() << "    "
-            << "(_" << name << "IsSet && "
-            << "(_" << name << " != other->_" << name << "))) {" << endl;
-      }
-      indent_up();
-      indent(out) << "return NO;" << endl;
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-  }
-
-  out << indent() << "return YES;" << endl;
-  scope_down(out);
-  out << endl;
-}
-
-/**
- * Generate struct implementation.
- *
- * @param tstruct      The struct definition
- * @param is_exception Is this an exception?
- * @param is_result    If this is a result it needs a different writer
- */
-void t_cocoa_generator::generate_cocoa_struct_implementation(ostream& out,
-                                                             t_struct* tstruct,
-                                                             bool is_exception,
-                                                             bool is_result) {
-  indent(out) << "@implementation " << cocoa_prefix_ << tstruct->get_name() << endl << endl;
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  // exceptions need to call the designated initializer on NSException
-  if (is_exception) {
-    out << indent() << "- (instancetype) init" << endl;
-    scope_up(out);
-    out << indent() << "return [super initWithDomain: " << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain" << endl
-        << indent() << "                        code: " << cocoa_prefix_ << capitalize(program_name_) << "Error" << tstruct->get_name() << endl
-        << indent() << "                    userInfo: nil];" << endl;
-    scope_down(out);
-    out << endl;
-  } else {
-    // struct
-
-    // default initializer
-    // setup instance variables with default values
-    indent(out) << "- (instancetype) init" << endl;
-    scope_up(out);
-    indent(out) << "self = [super init];" << endl;
-    indent(out) << "if (self)";
-    scope_up(out);
-    if (members.size() > 0) {
-      for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-        t_type* t = get_true_type((*m_iter)->get_type());
-        if ((*m_iter)->get_value() != NULL) {
-          print_const_value(out,
-                            "self." + (*m_iter)->get_name(),
-                            t,
-                            (*m_iter)->get_value(),
-                            false);
-        }
-      }
-    }
-    scope_down(out);
-    indent(out) << "return self;" << endl;
-    scope_down(out);
-    out << endl;
-  }
-
-  // initializer with all fields as params
-  if (!members.empty()) {
-    generate_cocoa_struct_initializer_signature(out, tstruct);
-    out << endl;
-    scope_up(out);
-    if (is_exception) {
-      out << indent() << "self = [self init];" << endl;
-    } else {
-      out << indent() << "self = [super init];" << endl;
-    }
-
-    indent(out) << "if (self)";
-    scope_up(out);
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      out << indent() << "_" << (*m_iter)->get_name() << " = ";
-      if (get_true_type((*m_iter)->get_type())->is_container()) {
-        out << "[" << (*m_iter)->get_name() << " mutableCopy];" << endl;
-      } else {
-        out << (*m_iter)->get_name() << ";" << endl;
-      }
-      out << indent() << "_" << (*m_iter)->get_name() << "IsSet = YES;" << endl;
-    }
-    scope_down(out);
-
-    out << indent() << "return self;" << endl;
-    scope_down(out);
-    out << endl;
-  }
-
-  // initWithCoder for NSCoding
-  generate_cocoa_struct_init_with_coder_method(out, tstruct, is_exception);
-  // encodeWithCoder for NSCoding
-  generate_cocoa_struct_encode_with_coder_method(out, tstruct, is_exception);
-  // hash and isEqual for NSObject
-  generate_cocoa_struct_hash_method(out, tstruct);
-  generate_cocoa_struct_is_equal_method(out, tstruct, is_exception);
-  // copy for NSObject
-  generate_cocoa_struct_copy_method(out, tstruct, is_exception);
-
-  // the rest of the methods
-  generate_cocoa_struct_field_accessor_implementations(out, tstruct, is_exception);
-  generate_cocoa_struct_reader(out, tstruct);
-  if (is_result) {
-    generate_cocoa_struct_result_writer(out, tstruct);
-  } else {
-    generate_cocoa_struct_writer(out, tstruct);
-  }
-  generate_cocoa_struct_validator(out, tstruct);
-  generate_cocoa_struct_description(out, tstruct);
-
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generates a function to read all the fields of the struct.
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_cocoa_struct_reader(ostream& out, t_struct* tstruct) {
-  out << "- (BOOL) read: (id <TProtocol>) inProtocol error: (NSError *__autoreleasing *)__thriftError" << endl;
-  scope_up(out);
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  // Declare stack tmp variables
-  indent(out) << "NSString * fieldName;" << endl;
-  indent(out) << "SInt32 fieldType;" << endl;
-  indent(out) << "SInt32 fieldID;" << endl;
-  out << endl;
-
-  indent(out) << "if (![inProtocol readStructBeginReturningName: NULL error: __thriftError]) return NO;" << endl;
-
-  // Loop over reading in fields
-  indent(out) << "while (true)" << endl;
-  scope_up(out);
-
-  // Read beginning field marker
-  indent(out)
-      << "if (![inProtocol readFieldBeginReturningName: &fieldName type: &fieldType fieldID: &fieldID error: __thriftError]) return NO;"
-      << endl;
-
-  // Check for field STOP marker and break
-  indent(out) << "if (fieldType == TTypeSTOP) { " << endl;
-  indent_up();
-  indent(out) << "break;" << endl;
-  indent_down();
-  indent(out) << "}" << endl;
-
-  // Switch statement on the field we are reading
-  indent(out) << "switch (fieldID)" << endl;
-
-  scope_up(out);
-
-  // Generate deserialization code for known cases
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl;
-    indent_up();
-    indent(out) << "if (fieldType == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl;
-    indent_up();
-
-    generate_deserialize_field(out, *f_iter, "fieldValue");
-    indent(out) << call_field_setter(*f_iter, "fieldValue") << endl;
-
-    indent_down();
-    out << indent() << "} else { " << endl;
-    if (log_unexpected_) {
-      out << indent() << "  NSLog(@\"%s: field ID %i has unexpected type %i.  Skipping.\", "
-                         "__PRETTY_FUNCTION__, (int)fieldID, (int)fieldType);" << endl;
-    }
-
-    out << indent() << "  if (![TProtocolUtil skipType: fieldType onProtocol: inProtocol error: __thriftError]) return NO;" << endl;
-    out << indent() << "}" << endl << indent() << "break;" << endl;
-    indent_down();
-  }
-
-  // In the default case we skip the field
-  out << indent() << "default:" << endl;
-  if (log_unexpected_) {
-    out << indent() << "  NSLog(@\"%s: unexpected field ID %i with type %i.  Skipping.\", "
-                       "__PRETTY_FUNCTION__, (int)fieldID, (int)fieldType);" << endl;
-  }
-
-  out << indent() << "  if (![TProtocolUtil skipType: fieldType onProtocol: inProtocol error: __thriftError]) return NO;" << endl;
-
-  out << indent() << "  break;" << endl;
-
-  scope_down(out);
-
-  // Read field end marker
-  indent(out) << "if (![inProtocol readFieldEnd: __thriftError]) return NO;" << endl;
-
-  scope_down(out);
-
-  out << indent() << "if (![inProtocol readStructEnd: __thriftError]) return NO;" << endl;
-
-  // performs various checks (e.g. check that all required fields are set)
-  if (validate_required_) {
-    out << indent() << "if (![self validate: __thriftError]) return NO;" << endl;
-  }
-
-  indent(out) << "return YES;" << endl;
-
-  indent_down();
-  out << indent() << "}" << endl << endl;
-}
-
-/**
- * Generates a function to write all the fields of the struct
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_cocoa_struct_writer(ostream& out, t_struct* tstruct) {
-  out << indent() << "- (BOOL) write: (id <TProtocol>) outProtocol error: (NSError *__autoreleasing *)__thriftError {" << endl;
-  indent_up();
-
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  out << indent() << "if (![outProtocol writeStructBeginWithName: @\"" << name << "\" error: __thriftError]) return NO;" << endl;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    out << indent() << "if (_" << (*f_iter)->get_name() << "IsSet) {" << endl;
-    indent_up();
-    bool null_allowed = type_can_be_null((*f_iter)->get_type());
-    if (null_allowed) {
-      out << indent() << "if (_" << (*f_iter)->get_name() << " != nil) {" << endl;
-      indent_up();
-    }
-
-    indent(out) << "if (![outProtocol writeFieldBeginWithName: @\"" << (*f_iter)->get_name()
-                << "\" type: " << type_to_enum((*f_iter)->get_type())
-                << " fieldID: " << (*f_iter)->get_key() << " error: __thriftError]) return NO;" << endl;
-
-    // Write field contents
-    generate_serialize_field(out, *f_iter, "_" + (*f_iter)->get_name());
-
-    // Write field closer
-    indent(out) << "if (![outProtocol writeFieldEnd: __thriftError]) return NO;" << endl;
-
-    if (null_allowed) {
-      scope_down(out);
-    }
-    scope_down(out);
-  }
-  // Write the struct map
-  out << indent() << "if (![outProtocol writeFieldStop: __thriftError]) return NO;" << endl
-      << indent() << "if (![outProtocol writeStructEnd: __thriftError]) return NO;" << endl;
-
-  indent(out) << "return YES;" << endl;
-
-  indent_down();
-  out << indent() << "}" << endl << endl;
-}
-
-/**
- * Generates a function to write all the fields of the struct, which
- * is a function result. These fields are only written if they are
- * set, and only one of them can be set at a time.
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_cocoa_struct_result_writer(ostream& out, t_struct* tstruct) {
-  out << indent() << "- (BOOL) write: (id <TProtocol>) outProtocol error: (NSError *__autoreleasing *)__thriftError {" << endl;
-  indent_up();
-
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  out << indent() << "if (![outProtocol writeStructBeginWithName: @\"" << name << "\" error: __thriftError]) return NO;" << endl;
-
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-      out << endl << indent() << "if ";
-    } else {
-      out << " else if ";
-    }
-
-    out << "(_" << (*f_iter)->get_name() << "IsSet) {" << endl;
-    indent_up();
-
-    bool null_allowed = type_can_be_null((*f_iter)->get_type());
-    if (null_allowed) {
-      out << indent() << "if (_" << (*f_iter)->get_name() << " != nil) {" << endl;
-      indent_up();
-    }
-
-    indent(out) << "if (![outProtocol writeFieldBeginWithName: @\"" << (*f_iter)->get_name()
-                << "\" type: " << type_to_enum((*f_iter)->get_type())
-                << " fieldID: " << (*f_iter)->get_key() << " error: __thriftError]) return NO;" << endl;
-
-    // Write field contents
-    generate_serialize_field(out, *f_iter, "_" + (*f_iter)->get_name());
-
-    // Write field closer
-    indent(out) << "if (![outProtocol writeFieldEnd: __thriftError]) return NO;" << endl;
-
-    if (null_allowed) {
-      indent_down();
-      indent(out) << "}" << endl;
-    }
-
-    indent_down();
-    indent(out) << "}";
-  }
-  // Write the struct map
-  out << endl << indent() << "if (![outProtocol writeFieldStop: __thriftError]) return NO;"
-      << endl << indent() << "if (![outProtocol writeStructEnd: __thriftError]) return NO;"
-      << endl;
-
-  indent(out) << "return YES;" << endl;
-
-  indent_down();
-  out << indent() << "}" << endl << endl;
-}
-
-/**
- * Generates a function to perform various checks
- * (e.g. check that all required fields are set)
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_cocoa_struct_validator(ostream& out, t_struct* tstruct) {
-  out << indent() << "- (BOOL) validate: (NSError *__autoreleasing *)__thriftError {" << endl;
-  indent_up();
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  out << indent() << "// check for required fields" << endl;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_field* field = (*f_iter);
-    if ((*f_iter)->get_req() == t_field::T_REQUIRED) {
-      out << indent() << "if (!_" << field->get_name() << "IsSet) ";
-      scope_up(out);
-      indent(out) << "if (__thriftError) ";
-      scope_up(out);
-      out << indent() << "*__thriftError = [NSError errorWithDomain: TProtocolErrorDomain" << endl
-          << indent() << "                                     code: TProtocolErrorUnknown" << endl
-          << indent() << "                                 userInfo: @{TProtocolErrorExtendedErrorKey: @(TProtocolExtendedErrorMissingRequiredField)," << endl
-          << indent() << "                                             TProtocolErrorFieldNameKey: @\"" << (*f_iter)->get_name() << "\"}];" << endl;
-      scope_down(out);
-      scope_down(out);
-    }
-  }
-  indent(out) << "return YES;" << endl;
-  indent_down();
-  out << indent() << "}" << endl << endl;
-}
-
-/**
- * Generate property accessor methods for all fields in the struct.
- * getter, setter, isset getter.
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_cocoa_struct_field_accessor_implementations(ostream& out,
-                                                                             t_struct* tstruct,
-                                                                             bool is_exception) {
-  (void)is_exception;
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_field* field = *f_iter;
-    t_type* type = get_true_type(field->get_type());
-    std::string field_name = field->get_name();
-    std::string cap_name = field_name;
-    cap_name[0] = toupper(cap_name[0]);
-
-    // Simple setter
-    indent(out) << "- (void) set" << cap_name << ": (" << type_name(type, false, true) << ") " << field_name
-                << " {" << endl;
-    indent_up();
-    indent(out) << "_" << field_name << " = " << field_name << ";" << endl;
-    indent(out) << "_" << field_name << "IsSet = YES;" << endl;
-    indent_down();
-    indent(out) << "}" << endl << endl;
-
-    // Unsetter - do we need this?
-    indent(out) << "- (void) unset" << cap_name << " {" << endl;
-    indent_up();
-    if (type_can_be_null(type)) {
-      indent(out) << "_" << field_name << " = nil;" << endl;
-    }
-    indent(out) << "_" << field_name << "IsSet = NO;" << endl;
-    indent_down();
-    indent(out) << "}" << endl << endl;
-  }
-}
-
-/**
- * Generates a description method for the given struct
- *
- * @param tstruct The struct definition
- */
-void t_cocoa_generator::generate_cocoa_struct_description(ostream& out, t_struct* tstruct) {
-
-  // Allow use of debugDescription so the app can add description via a cateogory/extension
-  if (debug_descriptions_) {
-    out << indent() << "- (NSString *) debugDescription {" << endl;
-  }
-  else {
-    out << indent() << "- (NSString *) description {" << endl;
-  }
-  indent_up();
-
-  out << indent() << "NSMutableString * ms = [NSMutableString stringWithString: @\""
-      << cocoa_prefix_ << tstruct->get_name() << "(\"];" << endl;
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-      indent(out) << "[ms appendString: @\"" << (*f_iter)->get_name() << ":\"];" << endl;
-    } else {
-      indent(out) << "[ms appendString: @\"," << (*f_iter)->get_name() << ":\"];" << endl;
-    }
-    t_type* ttype = (*f_iter)->get_type();
-    indent(out) << "[ms appendFormat: @\"" << format_string_for_type(ttype) << "\", "
-                << format_cast_for_type(ttype) << "_" << (*f_iter)->get_name() << "];" << endl;
-  }
-  out << indent() << "[ms appendString: @\")\"];" << endl << indent()
-      << "return [NSString stringWithString: ms];" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Generates a thrift service.  In Objective-C this consists of a
- * protocol definition, a client interface and a client implementation.
- *
- * @param tservice The service definition
- */
-void t_cocoa_generator::generate_service(t_service* tservice) {
-  generate_cocoa_service_protocol(f_header_, tservice);
-  generate_cocoa_service_client_interface(f_header_, tservice);
-  generate_cocoa_service_server_interface(f_header_, tservice);
-  generate_cocoa_service_helpers(tservice);
-  generate_cocoa_service_client_implementation(f_impl_, tservice);
-  generate_cocoa_service_server_implementation(f_impl_, tservice);
-  if (async_clients_) {
-    generate_cocoa_service_async_protocol(f_header_, tservice);
-    generate_cocoa_service_client_async_interface(f_header_, tservice);
-    generate_cocoa_service_client_async_implementation(f_impl_, tservice);
-  }
-}
-
-/**
- * Generates structs for all the service return types
- *
- * @param tservice The service
- */
-void t_cocoa_generator::generate_cocoa_service_helpers(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-
-    t_struct* ts = (*f_iter)->get_arglist();
-
-    string qname = function_args_helper_struct_type(tservice, *f_iter);
-
-    t_struct qname_ts = t_struct(ts->get_program(), qname);
-
-    const vector<t_field*>& members = ts->get_members();
-    vector<t_field*>::const_iterator m_iter;
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      qname_ts.append(*m_iter);
-    }
-
-    generate_cocoa_struct_interface(f_impl_, &qname_ts, false);
-    generate_cocoa_struct_implementation(f_impl_, &qname_ts, false, false);
-    generate_function_helpers(tservice, *f_iter);
-  }
-}
-
-string t_cocoa_generator::function_result_helper_struct_type(t_service *tservice, t_function* tfunction) {
-  if (tfunction->is_oneway()) {
-    return tservice->get_name() + "_" + tfunction->get_name();
-  } else {
-    return tservice->get_name() + "_" + tfunction->get_name() + "_result";
-  }
-}
-
-string t_cocoa_generator::function_args_helper_struct_type(t_service *tservice, t_function* tfunction) {
-  return tservice->get_name() + "_" + tfunction->get_name() + "_args";
-}
-
-/**
- * Generates a struct and helpers for a function.
- *
- * @param tfunction The function
- */
-void t_cocoa_generator::generate_function_helpers(t_service *tservice, t_function* tfunction) {
-  if (tfunction->is_oneway()) {
-    return;
-  }
-
-  // create a result struct with a success field of the return type,
-  // and a field for each type of exception thrown
-  t_struct result(program_, function_result_helper_struct_type(tservice, tfunction));
-  t_field success(tfunction->get_returntype(), "success", 0);
-  if (!tfunction->get_returntype()->is_void()) {
-    result.append(&success);
-  }
-
-  t_struct* xs = tfunction->get_xceptions();
-  const vector<t_field*>& fields = xs->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    result.append(*f_iter);
-  }
-
-  // generate the result struct
-  generate_cocoa_struct_interface(f_impl_, &result, false);
-  generate_cocoa_struct_implementation(f_impl_, &result, false, true);
-}
-
-/**
- * Generates a service protocol definition.
- *
- * @param tservice The service to generate a protocol definition for
- */
-void t_cocoa_generator::generate_cocoa_service_protocol(ostream& out, t_service* tservice) {
-  out << "@protocol " << cocoa_prefix_ << tservice->get_name() << " <NSObject>" << endl;
-
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    out << "- " << function_signature(*f_iter, true) << ";"
-        << "  // throws ";
-    t_struct* xs = (*f_iter)->get_xceptions();
-    const std::vector<t_field*>& xceptions = xs->get_members();
-    vector<t_field*>::const_iterator x_iter;
-    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-      out << type_name((*x_iter)->get_type()) + ", ";
-    }
-    out << "TException" << endl;
-  }
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generates an asynchronous service protocol definition.
- *
- * @param tservice The service to generate a protocol definition for
- */
-void t_cocoa_generator::generate_cocoa_service_async_protocol(ostream& out, t_service* tservice) {
-  out << "@protocol " << cocoa_prefix_ << tservice->get_name() << "Async"
-      << " <NSObject>" << endl;
-
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    out << "- " << async_function_signature(*f_iter, false) << ";" << endl;
-    if (promise_kit_) {
-      out << "- " << promise_function_signature(*f_iter) << ";" << endl;
-    }
-  }
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generates a service client interface definition.
- *
- * @param tservice The service to generate a client interface definition for
- */
-void t_cocoa_generator::generate_cocoa_service_client_interface(ostream& out,
-                                                                t_service* tservice) {
-  out << "@interface " << cocoa_prefix_ << tservice->get_name() << "Client : TBaseClient <"
-      << cocoa_prefix_ << tservice->get_name() << "> " << endl;
-
-  out << "- (id) initWithProtocol: (id <TProtocol>) protocol;" << endl;
-  out << "- (id) initWithInProtocol: (id <TProtocol>) inProtocol outProtocol: (id <TProtocol>) "
-         "outProtocol;" << endl;
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generates a service client interface definition.
- *
- * @param tservice The service to generate a client interface definition for
- */
-void t_cocoa_generator::generate_cocoa_service_client_async_interface(ostream& out,
-                                                                      t_service* tservice) {
-  out << "@interface " << cocoa_prefix_ << tservice->get_name() << "ClientAsync : TBaseClient <"
-      << cocoa_prefix_ << tservice->get_name() << "Async> " << endl
-      << endl;
-
-  out << "- (id) initWithProtocolFactory: (id <TProtocolFactory>) protocolFactory "
-      << "transportFactory: (id <TAsyncTransportFactory>) transportFactory;" << endl;
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generates a service server interface definition. In other words, the TProcess implementation for
- *the
- * service definition.
- *
- * @param tservice The service to generate a client interface definition for
- */
-void t_cocoa_generator::generate_cocoa_service_server_interface(ostream& out,
-                                                                t_service* tservice) {
-  out << "@interface " << cocoa_prefix_ << tservice->get_name()
-      << "Processor : NSObject <TProcessor> " << endl;
-
-  out << "- (id) initWith" << tservice->get_name() << ": (id <" << cocoa_prefix_
-      << tservice->get_name() << ">) service;" << endl;
-  out << "- (id<" << cocoa_prefix_ << tservice->get_name() << ">) service;" << endl;
-
-  out << "@end" << endl << endl;
-}
-
-void t_cocoa_generator::generate_cocoa_service_client_send_function_implementation(
-    ostream& out,
-    t_service *tservice,
-    t_function* tfunction,
-    bool needs_protocol) {
-  string funname = tfunction->get_name();
-
-  t_function send_function(g_type_bool,
-                           string("send_") + tfunction->get_name(),
-                           tfunction->get_arglist());
-
-  string argsname = function_args_helper_struct_type(tservice, tfunction);
-
-  // Open function
-  indent(out) << "- (BOOL) send_" << tfunction->get_name() << argument_list(tfunction->get_arglist(), needs_protocol ? "outProtocol" : "", true) << endl;
-  scope_up(out);
-
-  // Serialize the request
-  out << indent() << "if (![outProtocol writeMessageBeginWithName: @\"" << funname << "\""
-      << (tfunction->is_oneway() ? " type: TMessageTypeONEWAY" : " type: TMessageTypeCALL")
-      << " sequenceID: 0 error: __thriftError]) return NO;" << endl;
-
-  out << indent() << "if (![outProtocol writeStructBeginWithName: @\"" << argsname
-                  << "\" error: __thriftError]) return NO;" << endl;
-
-  // write out function parameters
-  t_struct* arg_struct = tfunction->get_arglist();
-  const vector<t_field*>& fields = arg_struct->get_members();
-  vector<t_field*>::const_iterator fld_iter;
-  for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-    string fieldName = (*fld_iter)->get_name();
-    if (type_can_be_null((*fld_iter)->get_type())) {
-      out << indent() << "if (" << fieldName << " != nil)";
-      scope_up(out);
-    }
-    out << indent() << "if (![outProtocol writeFieldBeginWithName: @\"" << fieldName
-        << "\""
-           " type: " << type_to_enum((*fld_iter)->get_type())
-        << " fieldID: " << (*fld_iter)->get_key() << " error: __thriftError]) return NO;" << endl;
-
-    generate_serialize_field(out, *fld_iter, fieldName);
-
-    out << indent() << "if (![outProtocol writeFieldEnd: __thriftError]) return NO;" << endl;
-
-    if (type_can_be_null((*fld_iter)->get_type())) {
-      indent_down();
-      out << indent() << "}" << endl;
-    }
-  }
-
-  out << indent() << "if (![outProtocol writeFieldStop: __thriftError]) return NO;" << endl;
-  out << indent() << "if (![outProtocol writeStructEnd: __thriftError]) return NO;" << endl;
-  out << indent() << "if (![outProtocol writeMessageEnd: __thriftError]) return NO;" << endl;
-  out << indent() << "return YES;" << endl;
-  scope_down(out);
-  out << endl;
-}
-
-void t_cocoa_generator::generate_cocoa_service_client_recv_function_implementation(
-    ostream& out,
-    t_service* tservice,
-    t_function* tfunction,
-    bool needs_protocol) {
-
-
-  // Open function
-  indent(out) << "- (BOOL) recv_" << tfunction->get_name();
-  if (!tfunction->get_returntype()->is_void()) {
-    out << ": (" << type_name(tfunction->get_returntype(), false, true) << " *) result ";
-    if (needs_protocol) {
-      out << "protocol";
-    } else {
-      out << "error";
-    }
-  }
-  if (needs_protocol) {
-    out << ": (id<TProtocol>) inProtocol error";
-  }
-  out << ": (NSError *__autoreleasing *)__thriftError" << endl;
-  scope_up(out);
-
-  // TODO(mcslee): Message validation here, was the seqid etc ok?
-
-  // check for an exception
-  out << indent() << "NSError *incomingException = [self checkIncomingMessageException: inProtocol];" << endl
-      << indent() << "if (incomingException)";
-  scope_up(out);
-  out << indent() << "if (__thriftError)";
-  scope_up(out);
-  out << indent() << "*__thriftError = incomingException;" << endl;
-  scope_down(out);
-  out << indent() << "return NO;" << endl;
-  scope_down(out);
-
-  // FIXME - could optimize here to reduce creation of temporary objects.
-  string resultname = function_result_helper_struct_type(tservice, tfunction);
-  out << indent() << cocoa_prefix_ << resultname << " * resulter = [" << cocoa_prefix_ << resultname << " new];" << endl;
-  indent(out) << "if (![resulter read: inProtocol error: __thriftError]) return NO;" << endl;
-  indent(out) << "if (![inProtocol readMessageEnd: __thriftError]) return NO;" << endl;
-
-  // Careful, only return _result if not a void function
-  if (!tfunction->get_returntype()->is_void()) {
-    out << indent() << "if (resulter.successIsSet)";
-    scope_up(out);
-    out << indent() << "*result = resulter.success;" << endl;
-    out << indent() << "return YES;" << endl;
-    scope_down(out);
-  }
-
-  t_struct* xs = tfunction->get_xceptions();
-  const std::vector<t_field*>& xceptions = xs->get_members();
-  vector<t_field*>::const_iterator x_iter;
-  for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-    out << indent() << "if (resulter." << (*x_iter)->get_name() << "IsSet)";
-    scope_up(out);
-    out << indent() << "if (__thriftError)";
-    scope_up(out);
-    out << indent() << "*__thriftError = [resulter " << (*x_iter)->get_name() << "];" << endl;
-    scope_down(out);
-    out << indent() << "return NO;" << endl;
-    scope_down(out);
-  }
-
-  // If you get here it's an exception, unless a void function
-  if (tfunction->get_returntype()->is_void()) {
-    indent(out) << "return YES;" << endl;
-  } else {
-    out << indent() << "if (__thriftError)";
-    scope_up(out);
-    out << indent() << "*__thriftError = [NSError errorWithDomain: TApplicationErrorDomain" << endl
-        << indent() << "                                     code: TApplicationErrorMissingResult" << endl
-        << indent() << "                                 userInfo: @{TApplicationErrorMethodKey: @\""
-        << tfunction->get_name() << "\"}];" << endl;
-    scope_down(out);
-    out << indent() << "return NO;" << endl;
-  }
-
-  // Close function
-  scope_down(out);
-  out << endl;
-}
-
-/**
- * Generates an invocation of a given 'send_' function.
- *
- * @param tfunction The service to generate an implementation for
- */
-void t_cocoa_generator::generate_cocoa_service_client_send_function_invocation(
-                                                                               ostream& out,
-                                                                               t_function* tfunction) {
-
-  t_struct* arg_struct = tfunction->get_arglist();
-  const vector<t_field*>& fields = arg_struct->get_members();
-  vector<t_field*>::const_iterator fld_iter;
-  out << indent() << "if (![self send_" << tfunction->get_name();
-  bool first = true;
-  for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-    string fieldName = (*fld_iter)->get_name();
-    out << " ";
-    if (first) {
-      first = false;
-      out << ": " << fieldName;
-    } else {
-      out << fieldName << ": " << fieldName;
-    }
-  }
-  if (!fields.empty()) {
-    out << " error";
-  }
-  out << ": __thriftError]) " << invalid_return_statement(tfunction) << endl;
-}
-
-/**
- * Generates an invocation of a given 'send_' function.
- *
- * @param tfunction The service to generate an implementation for
- */
-void t_cocoa_generator::generate_cocoa_service_client_send_async_function_invocation(
-                                                                                     ostream& out,
-                                                                                     t_function* tfunction,
-                                                                                     string failureBlockName) {
-
-  t_struct* arg_struct = tfunction->get_arglist();
-  const vector<t_field*>& fields = arg_struct->get_members();
-  vector<t_field*>::const_iterator fld_iter;
-  out << indent() << "if (![self send_" << tfunction->get_name();
-  bool first = true;
-  for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-    string fieldName = (*fld_iter)->get_name();
-    out << " ";
-    if (first) {
-      first = false;
-      out << ": " << fieldName;
-    } else {
-      out << fieldName << ": " << fieldName;
-    }
-  }
-  if (!fields.empty()) {
-    out << " protocol";
-  }
-  out << ": protocol error: &thriftError]) ";
-  scope_up(out);
-  out << indent() << failureBlockName << "(thriftError);" << endl
-      << indent() << "return;" << endl;
-  scope_down(out);
-}
-
-/**
- * Generates a service client implementation.
- *
- * @param tservice The service to generate an implementation for
- */
-void t_cocoa_generator::generate_cocoa_service_client_implementation(ostream& out,
-                                                                     t_service* tservice) {
-
-  string name = cocoa_prefix_ + tservice->get_name() + "Client";
-
-  out << "@interface " << name << " () ";
-  scope_up(out);
-  out << endl;
-  out << indent() << "id<TProtocol> inProtocol;" << endl;
-  out << indent() << "id<TProtocol> outProtocol;" << endl;
-  out << endl;
-  scope_down(out);
-  out << endl;
-  out << "@end" << endl << endl;
-
-  out << "@implementation " << name << endl;
-
-  // initializers
-  out << "- (id) initWithProtocol: (id <TProtocol>) protocol" << endl;
-  scope_up(out);
-  out << indent() << "return [self initWithInProtocol: protocol outProtocol: protocol];" << endl;
-  scope_down(out);
-  out << endl;
-
-  out << "- (id) initWithInProtocol: (id <TProtocol>) anInProtocol outProtocol: (id <TProtocol>) "
-         "anOutProtocol" << endl;
-  scope_up(out);
-  out << indent() << "self = [super init];" << endl;
-  out << indent() << "if (self) ";
-  scope_up(out);
-  out << indent() << "inProtocol = anInProtocol;" << endl;
-  out << indent() << "outProtocol = anOutProtocol;" << endl;
-  scope_down(out);
-  out << indent() << "return self;" << endl;
-  scope_down(out);
-  out << endl;
-
-  // generate client method implementations
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-
-    generate_cocoa_service_client_send_function_implementation(out, tservice, *f_iter, false);
-
-    if (!(*f_iter)->is_oneway()) {
-      generate_cocoa_service_client_recv_function_implementation(out, tservice, *f_iter, false);
-    }
-
-    // Open function
-    indent(out) << "- " << function_signature(*f_iter, true) << endl;
-    scope_up(out);
-    generate_cocoa_service_client_send_function_invocation(out, *f_iter);
-
-    out << indent() << "if (![[outProtocol transport] flush: __thriftError]) " << invalid_return_statement(*f_iter) << endl;
-    if (!(*f_iter)->is_oneway()) {
-      if ((*f_iter)->get_returntype()->is_void()) {
-        out << indent() << "if (![self recv_" << (*f_iter)->get_name() << ": __thriftError]) return NO;" << endl;
-        out << indent() << "return YES;" << endl;
-      } else {
-        out << indent() << type_name((*f_iter)->get_returntype(), false, true) << " __result;" << endl
-            << indent() << "if (![self recv_" << (*f_iter)->get_name() << ": &__result error: __thriftError]) "
-            << invalid_return_statement(*f_iter) << endl;
-        if (type_can_be_null((*f_iter)->get_returntype())) {
-          out << indent() << "return __result;" << endl;
-        } else {
-          out << indent() << "return @(__result);" << endl;
-        }
-      }
-    }
-    else {
-      out << indent() << "return YES;" << endl;
-    }
-    scope_down(out);
-    out << endl;
-  }
-
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generates a service client implementation for its asynchronous interface.
- *
- * @param tservice The service to generate an implementation for
- */
-void t_cocoa_generator::generate_cocoa_service_client_async_implementation(ostream& out,
-                                                                           t_service* tservice) {
-
-  string name = cocoa_prefix_ + tservice->get_name() + "ClientAsync";
-
-  out << "@interface " << name << " () ";
-  scope_up(out);
-  out << endl;
-  out << indent() << "id<TProtocolFactory> protocolFactory;" << endl;
-  out << indent() << "id<TAsyncTransportFactory> transportFactory;" << endl;
-  out << endl;
-  scope_down(out);
-  out << endl;
-  out << "@end" << endl << endl;
-
-
-  out << "@implementation " << name << endl
-      << endl << "- (id) initWithProtocolFactory: (id <TProtocolFactory>) aProtocolFactory "
-                 "transportFactory: (id <TAsyncTransportFactory>) aTransportFactory;" << endl;
-
-  scope_up(out);
-  out << indent() << "self = [super init];" << endl;
-  out << indent() << "if (self) {" << endl;
-  out << indent() << "  protocolFactory = aProtocolFactory;" << endl;
-  out << indent() << "  transportFactory = aTransportFactory;" << endl;
-  out << indent() << "}" << endl;
-  out << indent() << "return self;" << endl;
-  scope_down(out);
-  out << endl;
-
-  // generate client method implementations
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-
-    generate_cocoa_service_client_send_function_implementation(out, tservice, *f_iter, true);
-
-    if (!(*f_iter)->is_oneway()) {
-      generate_cocoa_service_client_recv_function_implementation(out, tservice, *f_iter, true);
-    }
-
-    // Open function
-    indent(out) << "- " << async_function_signature(*f_iter, false) << endl;
-    scope_up(out);
-
-    out << indent() << "NSError *thriftError;" << endl
-        << indent() << "id<TAsyncTransport> transport = [transportFactory newTransport];" << endl
-        << indent() << "id<TProtocol> protocol = [protocolFactory newProtocolOnTransport:transport];" << endl
-        << endl;
-
-    generate_cocoa_service_client_send_async_function_invocation(out, *f_iter, "failureBlock");
-
-    out << indent() << "[transport flushWithCompletion:^{" << endl;
-    indent_up();
-
-    if (!(*f_iter)->is_oneway()) {
-      out << indent() << "NSError *thriftError;" << endl;
-
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        out << indent() << type_name((*f_iter)->get_returntype()) << " result;" << endl;
-      }
-      out << indent() << "if (![self recv_" << (*f_iter)->get_name();
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        out << ": &result protocol";
-      }
-      out << ": protocol error: &thriftError]) ";
-      scope_up(out);
-      out << indent() << "failureBlock(thriftError);" << endl
-          << indent() << "return;" << endl;
-      scope_down(out);
-    }
-
-    out << indent() << "responseBlock(";
-    if (!(*f_iter)->is_oneway() && !(*f_iter)->get_returntype()->is_void()) {
-      out << "result";
-    }
-    out << ");" << endl;
-
-    indent_down();
-
-    out << indent() << "} failure:failureBlock];" << endl;
-
-    scope_down(out);
-
-    out << endl;
-
-    // Promise function
-    if (promise_kit_) {
-
-      indent(out) << "- " << promise_function_signature(*f_iter) << endl;
-      scope_up(out);
-
-      out << indent() << "return [AnyPromise promiseWithResolverBlock:^(PMKResolver resolver) {" << endl;
-      indent_up();
-
-      out << indent() << "NSError *thriftError;" << endl
-          << indent() << "id<TAsyncTransport> transport = [transportFactory newTransport];" << endl
-          << indent() << "id<TProtocol> protocol = [protocolFactory newProtocolOnTransport:transport];" << endl
-          << endl;
-
-      generate_cocoa_service_client_send_async_function_invocation(out, *f_iter, "resolver");
-
-      out << indent() << "[transport flushWithCompletion:^{" << endl;
-      indent_up();
-
-      if (!(*f_iter)->is_oneway()) {
-        out << indent() << "NSError *thriftError;" << endl;
-
-        if (!(*f_iter)->get_returntype()->is_void()) {
-          out << indent() << type_name((*f_iter)->get_returntype()) << " result;" << endl;
-        }
-        out << indent() << "if (![self recv_" << (*f_iter)->get_name();
-        if (!(*f_iter)->get_returntype()->is_void()) {
-          out << ": &result protocol";
-        }
-        out << ": protocol error: &thriftError]) ";
-        scope_up(out);
-        out << indent() << "resolver(thriftError);" << endl
-            << indent() << "return;" << endl;
-        scope_down(out);
-      }
-
-      out << indent() << "resolver(";
-      if ((*f_iter)->is_oneway() || (*f_iter)->get_returntype()->is_void()) {
-        out << "@YES";
-      } else if (type_can_be_null((*f_iter)->get_returntype())) {
-        out << "result";
-      } else {
-        out << "@(result)";
-      }
-      out << ");" << endl;
-
-      indent_down();
-
-      out << indent() << "} failure:^(NSError *error) {" << endl;
-      indent_up();
-      out << indent() << "resolver(error);" << endl;
-      indent_down();
-      out << indent() << "}];" << endl;
-
-      indent_down();
-      out << indent() << "}];" << endl;
-
-      scope_down(out);
-
-      out << endl;
-
-    }
-
-  }
-
-  out << "@end" << endl << endl;
-}
-
-/**
- * Generates a service server implementation.  In other words the actual TProcessor implementation
- * for the service.
- *
- * @param tservice The service to generate an implementation for
- */
-void t_cocoa_generator::generate_cocoa_service_server_implementation(ostream& out,
-                                                                     t_service* tservice) {
-
-  string name = cocoa_prefix_ + tservice->get_name() + "Processor";
-
-  out << "@interface " << name << " () ";
-
-  scope_up(out);
-  out << indent() << "id <" << cocoa_prefix_ << tservice->get_name() << "> service;" << endl;
-  out << indent() << "NSDictionary * methodMap;" << endl;
-  scope_down(out);
-
-  out << "@end" << endl << endl;
-
-  out << "@implementation " << name << endl;
-
-  // initializer
-  out << endl;
-  out << "- (id) initWith" << tservice->get_name() << ": (id <" << cocoa_prefix_ << tservice->get_name() << ">) aService" << endl;
-  scope_up(out);
-  out << indent() << "self = [super init];" << endl;
-  out << indent() << "if (self) ";
-  scope_up(out);
-  out << indent() << "service = aService;" << endl;
-  out << indent() << "methodMap = [NSMutableDictionary dictionary];" << endl;
-
-  // generate method map for routing incoming calls
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    string funname = (*f_iter)->get_name();
-    scope_up(out);
-    out << indent() << "SEL s = @selector(process_" << funname << "_withSequenceID:inProtocol:outProtocol:error:);" << endl;
-    out << indent() << "NSMethodSignature * sig = [self methodSignatureForSelector: s];" << endl;
-    out << indent() << "NSInvocation * invocation = [NSInvocation invocationWithMethodSignature: sig];" << endl;
-    out << indent() << "[invocation setSelector: s];" << endl;
-    out << indent() << "[invocation retainArguments];" << endl;
-    out << indent() << "[methodMap setValue: invocation forKey: @\"" << funname << "\"];" << endl;
-    scope_down(out);
-  }
-  scope_down(out);
-  out << indent() << "return self;" << endl;
-  scope_down(out);
-
-  // implementation of the 'service' method which returns the service associated with this
-  // processor
-  out << endl;
-  out << indent() << "- (id<" << cocoa_prefix_ << tservice->get_name() << ">) service" << endl;
-  out << indent() << "{" << endl;
-  out << indent() << "  return service;" << endl;
-  out << indent() << "}" << endl;
-
-  // implementation of the TProcess method, which dispatches the incoming call using the method map
-  out << endl;
-  out << indent() << "- (BOOL) processOnInputProtocol: (id <TProtocol>) inProtocol" << endl;
-  out << indent() << "                 outputProtocol: (id <TProtocol>) outProtocol" << endl;
-  out << indent() << "                          error: (NSError *__autoreleasing *)__thriftError" << endl;
-  out << indent() << "{" << endl;
-  out << indent() << "  NSString * messageName;" << endl;
-  out << indent() << "  SInt32 messageType;" << endl;
-  out << indent() << "  SInt32 seqID;" << endl;
-  out << indent() << "  if (![inProtocol readMessageBeginReturningName: &messageName" << endl;
-  out << indent() << "                                       type: &messageType" << endl;
-  out << indent() << "                                 sequenceID: &seqID" << endl;
-  out << indent() << "                                      error: __thriftError]) return NO;" << endl;
-  out << indent() << "  NSInvocation * invocation = [methodMap valueForKey: messageName];" << endl;
-  out << indent() << "  if (invocation == nil) {" << endl;
-  out << indent() << "    if (![TProtocolUtil skipType: TTypeSTRUCT onProtocol: inProtocol error: __thriftError]) return NO;" << endl;
-  out << indent() << "    if (![inProtocol readMessageEnd: __thriftError]) return NO;" << endl;
-  out << indent() << "    NSError * x = [NSError errorWithDomain: TApplicationErrorDomain" << endl;
-  out << indent() << "                                      code: TApplicationErrorUnknownMethod" << endl;
-  out << indent() << "                                  userInfo: @{TApplicationErrorMethodKey: messageName}];" << endl;
-  out << indent() << "    if (![outProtocol writeMessageBeginWithName: messageName" << endl;
-  out << indent() << "                                           type: TMessageTypeEXCEPTION" << endl;
-  out << indent() << "                                     sequenceID: seqID" << endl;
-  out << indent() << "                                          error: __thriftError]) return NO;" << endl;
-  out << indent() << "    if (![x write: outProtocol error: __thriftError]) return NO;" << endl;
-  out << indent() << "    if (![outProtocol writeMessageEnd: __thriftError]) return NO;" << endl;
-  out << indent() << "    if (![[outProtocol transport] flush: __thriftError]) return NO;" << endl;
-  out << indent() << "    return YES;" << endl;
-  out << indent() << "  }" << endl;
-  out << indent() << "  // NSInvocation does not conform to NSCopying protocol" << endl;
-  out << indent() << "  NSInvocation * i = [NSInvocation invocationWithMethodSignature: "
-                     "[invocation methodSignature]];" << endl;
-  out << indent() << "  [i setSelector: [invocation selector]];" << endl;
-  out << indent() << "  [i setArgument: &seqID atIndex: 2];" << endl;
-  out << indent() << "  [i setArgument: &inProtocol atIndex: 3];" << endl;
-  out << indent() << "  [i setArgument: &outProtocol atIndex: 4];" << endl;
-  out << indent() << "  [i setArgument: &__thriftError atIndex: 5];" << endl;
-  out << indent() << "  [i setTarget: self];" << endl;
-  out << indent() << "  [i invoke];" << endl;
-  out << indent() << "  return YES;" << endl;
-  out << indent() << "}" << endl;
-
-  // generate a process_XXXX method for each service function, which reads args, calls the service,
-  // and writes results
-  functions = tservice->get_functions();
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    out << endl;
-    string funname = (*f_iter)->get_name();
-    out << indent() << "- (BOOL) process_" << funname
-        << "_withSequenceID: (SInt32) seqID inProtocol: (id<TProtocol>) inProtocol outProtocol: "
-           "(id<TProtocol>) outProtocol error:(NSError *__autoreleasing *)__thriftError" << endl;
-    scope_up(out);
-    string argstype = cocoa_prefix_ + function_args_helper_struct_type(tservice, *f_iter);
-    out << indent() << argstype << " * args = [" << argstype << " new];" << endl;
-    out << indent() << "if (![args read: inProtocol error: __thriftError]) return NO;" << endl;
-    out << indent() << "if (![inProtocol readMessageEnd: __thriftError]) return NO;" << endl;
-
-    // prepare the result if not oneway
-    if (!(*f_iter)->is_oneway()) {
-      string resulttype = cocoa_prefix_ + function_result_helper_struct_type(tservice, *f_iter);
-      out << indent() << resulttype << " * result = [" << resulttype << " new];" << endl;
-    }
-
-    // make the call to the actual service object
-    out << indent();
-    if ((*f_iter)->get_returntype()->is_void()) {
-      out << "BOOL";
-    } else if (type_can_be_null((*f_iter)->get_returntype())) {
-      out << type_name((*f_iter)->get_returntype(), false, true);
-    } else {
-      out << "NSNumber *";
-    }
-    out << " serviceResult = ";
-    if ((*f_iter)->get_returntype()->get_true_type()->is_container()) {
-      out << "(" << type_name((*f_iter)->get_returntype(), false, true) << ")";
-    }
-    out << "[service " << funname;
-    // supplying arguments
-    t_struct* arg_struct = (*f_iter)->get_arglist();
-    const vector<t_field*>& fields = arg_struct->get_members();
-    vector<t_field*>::const_iterator fld_iter;
-    bool first = true;
-    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-      string fieldName = (*fld_iter)->get_name();
-      if (first) {
-        first = false;
-        out << ": [args " << fieldName << "]";
-      } else {
-        out << " " << fieldName << ": [args " << fieldName << "]";
-      }
-    }
-    if (!fields.empty()) {
-      out << " error";
-    }
-    out << ": __thriftError];" << endl;
-    out << indent() << "if (!serviceResult) return NO;" << endl;
-    if (!(*f_iter)->get_returntype()->is_void()) {
-      out << indent() << "[result setSuccess: " << unbox((*f_iter)->get_returntype(), "serviceResult") << "];" << endl;
-    }
-
-    // write out the result if not oneway
-    if (!(*f_iter)->is_oneway()) {
-      out << indent() << "if (![outProtocol writeMessageBeginWithName: @\"" << funname << "\"" << endl;
-      out << indent() << "                                       type: TMessageTypeREPLY" << endl;
-      out << indent() << "                                 sequenceID: seqID" << endl;
-      out << indent() << "                                      error: __thriftError]) return NO;" << endl;
-      out << indent() << "if (![result write: outProtocol error: __thriftError]) return NO;" << endl;
-      out << indent() << "if (![outProtocol writeMessageEnd: __thriftError]) return NO;" << endl;
-      out << indent() << "if (![[outProtocol transport] flush: __thriftError]) return NO;" << endl;
-    }
-    out << indent() << "return YES;" << endl;
-
-    scope_down(out);
-  }
-
-  out << "@end" << endl << endl;
-}
-
-/**
- * Deserializes a field of any type.
- *
- * @param tfield The field
- * @param fieldName The variable name for this field
- */
-void t_cocoa_generator::generate_deserialize_field(ostream& out,
-                                                   t_field* tfield,
-                                                   string fieldName) {
-  t_type* type = get_true_type(tfield->get_type());
-
-  if (type->is_void()) {
-    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + tfield->get_name();
-  }
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_deserialize_struct(out, (t_struct*)type, fieldName);
-  } else if (type->is_container()) {
-    generate_deserialize_container(out, type, fieldName);
-  } else if (type->is_base_type() || type->is_enum()) {
-    indent(out) << type_name(type) << " " << fieldName << ";" << endl;
-    indent(out) << "if (![inProtocol ";
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + tfield->get_name();
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "readBinary:&" << fieldName << " error: __thriftError]";
-        } else {
-          out << "readString:&" << fieldName << " error: __thriftError]";
-        }
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "readBool:&" << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I8:
-        out << "readByte:(UInt8 *)&" << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I16:
-        out << "readI16:&" << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I32:
-        out << "readI32:&" << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I64:
-        out << "readI64:&" << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "readDouble:&" << fieldName << " error: __thriftError]";
-        break;
-      default:
-        throw "compiler error: no Objective-C name for base type "
-            + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      out << "readI32:&" << fieldName << " error: __thriftError]";
-    }
-    out << ") return NO;" << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n",
-           tfield->get_name().c_str(),
-           type_name(type).c_str());
-  }
-}
-
-/**
- * Generates an unserializer for a struct, allocates the struct and invokes read:
- */
-void t_cocoa_generator::generate_deserialize_struct(ostream& out,
-                                                    t_struct* tstruct,
-                                                    string fieldName) {
-  indent(out) << type_name(tstruct) << fieldName << " = [[" << type_name(tstruct, true)
-              << " alloc] init];" << endl;
-  indent(out) << "if (![" << fieldName << " read: inProtocol error: __thriftError]) return NO;" << endl;
-}
-
-/**
- * Deserializes a container by reading its size and then iterating
- */
-void t_cocoa_generator::generate_deserialize_container(ostream& out,
-                                                       t_type* ttype,
-                                                       string fieldName) {
-  string size = tmp("_size");
-  indent(out) << "SInt32 " << size << ";" << endl;
-
-  // Declare variables, read header
-  if (ttype->is_map()) {
-    indent(out) << "if (![inProtocol readMapBeginReturningKeyType: NULL valueType: NULL size: &" << size << " error: __thriftError]) return NO;" << endl;
-    indent(out) << "NSMutableDictionary * " << fieldName
-                << " = [[NSMutableDictionary alloc] initWithCapacity: " << size << "];" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "if (![inProtocol readSetBeginReturningElementType: NULL size: &" << size << " error: __thriftError]) return NO;"
-                << endl;
-    indent(out) << "NSMutableSet * " << fieldName
-                << " = [[NSMutableSet alloc] initWithCapacity: " << size << "];" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "if (![inProtocol readListBeginReturningElementType: NULL size: &" << size << " error: __thriftError]) return NO;"
-                << endl;
-    indent(out) << "NSMutableArray * " << fieldName
-                << " = [[NSMutableArray alloc] initWithCapacity: " << size << "];" << endl;
-  }
-  // FIXME - the code above does not verify that the element types of
-  // the containers being read match the element types of the
-  // containers we are reading into.  Does that matter?
-
-  // For loop iterates over elements
-  string i = tmp("_i");
-  indent(out) << "int " << i << ";" << endl << indent() << "for (" << i << " = 0; " << i << " < "
-              << size << "; "
-              << "++" << i << ")" << endl;
-
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    generate_deserialize_map_element(out, (t_map*)ttype, fieldName);
-  } else if (ttype->is_set()) {
-    generate_deserialize_set_element(out, (t_set*)ttype, fieldName);
-  } else if (ttype->is_list()) {
-    generate_deserialize_list_element(out, (t_list*)ttype, fieldName);
-  }
-
-  scope_down(out);
-
-  // Read container end
-  if (ttype->is_map()) {
-    indent(out) << "if (![inProtocol readMapEnd: __thriftError]) return NO;" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "if (![inProtocol readSetEnd: __thriftError]) return NO;" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "if (![inProtocol readListEnd: __thriftError]) return NO;" << endl;
-  }
-}
-
-/**
- * Take a variable of a given type and wrap it in code to make it
- * suitable for putting into a container, if necessary.  Basically,
- * wrap scaler primitives in NSNumber objects.
- */
-string t_cocoa_generator::box(t_type* ttype, string field_name) {
-
-  ttype = get_true_type(ttype);
-  if (ttype->is_enum()) {
-    return "@(" + field_name + ")";
-  } else if (ttype->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
-    switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "can't box void";
-      case t_base_type::TYPE_BOOL:
-      case t_base_type::TYPE_I8:
-      case t_base_type::TYPE_I16:
-      case t_base_type::TYPE_I32:
-      case t_base_type::TYPE_I64:
-      case t_base_type::TYPE_DOUBLE:
-        return "@(" + field_name + ")";
-      default:
-        break;
-    }
-  }
-
-  // do nothing
-  return field_name;
-}
-
-/**
- * Extracts the actual value from a boxed value
- */
-string t_cocoa_generator::unbox(t_type* ttype, string field_name) {
-  ttype = get_true_type(ttype);
-  if (ttype->is_enum()) {
-    return "[" + field_name + " intValue]";
-  } else if (ttype->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
-    switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "can't unbox void";
-      case t_base_type::TYPE_BOOL:
-        return "[" + field_name + " boolValue]";
-      case t_base_type::TYPE_I8:
-        return "((SInt8)[" + field_name + " charValue])";
-      case t_base_type::TYPE_I16:
-        return "((SInt16)[" + field_name + " shortValue])";
-      case t_base_type::TYPE_I32:
-        return "((SInt32)[" + field_name + " longValue])";
-      case t_base_type::TYPE_I64:
-        return "((SInt64)[" + field_name + " longLongValue])";
-      case t_base_type::TYPE_DOUBLE:
-        return "[" + field_name + " doubleValue]";
-      default:
-        break;
-    }
-  }
-
-  // do nothing
-  return field_name;
-}
-
-/**
- * Generates code to deserialize a map element
- */
-void t_cocoa_generator::generate_deserialize_map_element(ostream& out,
-                                                         t_map* tmap,
-                                                         string fieldName) {
-  string key = tmp("_key");
-  string val = tmp("_val");
-  t_type* keyType = tmap->get_key_type();
-  t_type* valType = tmap->get_val_type();
-  t_field fkey(keyType, key);
-  t_field fval(valType, val);
-
-  generate_deserialize_field(out, &fkey, key);
-  generate_deserialize_field(out, &fval, val);
-
-  indent(out) << "[" << fieldName << " setObject: " << box(valType, val)
-              << " forKey: " << box(keyType, key) << "];" << endl;
-}
-
-/**
- * Deserializes a set element
- */
-void t_cocoa_generator::generate_deserialize_set_element(ostream& out,
-                                                         t_set* tset,
-                                                         string fieldName) {
-  string elem = tmp("_elem");
-  t_type* type = tset->get_elem_type();
-  t_field felem(type, elem);
-
-  generate_deserialize_field(out, &felem, elem);
-
-  indent(out) << "[" << fieldName << " addObject: " << box(type, elem) << "];" << endl;
-}
-
-/**
- * Deserializes a list element
- */
-void t_cocoa_generator::generate_deserialize_list_element(ostream& out,
-                                                          t_list* tlist,
-                                                          string fieldName) {
-  string elem = tmp("_elem");
-  t_type* type = tlist->get_elem_type();
-  t_field felem(type, elem);
-
-  generate_deserialize_field(out, &felem, elem);
-
-  indent(out) << "[" << fieldName << " addObject: " << box(type, elem) << "];" << endl;
-}
-
-/**
- * Serializes a field of any type.
- *
- * @param tfield The field to serialize
- * @param fieldName Name to of the variable holding the field
- */
-void t_cocoa_generator::generate_serialize_field(ostream& out, t_field* tfield, string fieldName) {
-  t_type* type = get_true_type(tfield->get_type());
-
-  // Do nothing for void types
-  if (type->is_void()) {
-    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + tfield->get_name();
-  }
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_serialize_struct(out, (t_struct*)type, fieldName);
-  } else if (type->is_container()) {
-    generate_serialize_container(out, type, fieldName);
-  } else if (type->is_base_type() || type->is_enum()) {
-    indent(out) << "if (![outProtocol ";
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + fieldName;
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "writeBinary: " << fieldName << " error: __thriftError]";
-        } else {
-          out << "writeString: " << fieldName << " error: __thriftError]";
-        }
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "writeBool: " << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I8:
-        out << "writeByte: (UInt8)" << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I16:
-        out << "writeI16: " << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I32:
-        out << "writeI32: " << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_I64:
-        out << "writeI64: " << fieldName << " error: __thriftError]";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "writeDouble: " << fieldName << " error: __thriftError]";
-        break;
-      default:
-        throw "compiler error: no Objective-C name for base type "
-            + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      out << "writeI32: " << fieldName << " error: __thriftError]";
-    }
-    out << ") return NO;" << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s' TYPE '%s'\n",
-           tfield->get_name().c_str(),
-           type_name(type).c_str());
-  }
-}
-
-/**
- * Serialize a struct.
- *
- * @param tstruct The struct to serialize
- * @param fieldName Name of variable holding struct
- */
-void t_cocoa_generator::generate_serialize_struct(ostream& out,
-                                                  t_struct* tstruct,
-                                                  string fieldName) {
-  (void)tstruct;
-  out << indent() << "if (![" << fieldName << " write: outProtocol error: __thriftError]) return NO;" << endl;
-}
-
-/**
- * Serializes a container by writing its size then the elements.
- *
- * @param ttype  The type of container
- * @param fieldName Name of variable holding container
- */
-void t_cocoa_generator::generate_serialize_container(ostream& out,
-                                                     t_type* ttype,
-                                                     string fieldName) {
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "if (![outProtocol writeMapBeginWithKeyType: "
-                << type_to_enum(((t_map*)ttype)->get_key_type())
-                << " valueType: " << type_to_enum(((t_map*)ttype)->get_val_type()) << " size: (SInt32)["
-                << fieldName << " count] error: __thriftError]) return NO;" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "if (![outProtocol writeSetBeginWithElementType: "
-                << type_to_enum(((t_set*)ttype)->get_elem_type()) << " size: (SInt32)[" << fieldName
-                << " count] error: __thriftError]) return NO;" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "if (![outProtocol writeListBeginWithElementType: "
-                << type_to_enum(((t_list*)ttype)->get_elem_type()) << " size: (SInt32)[" << fieldName
-                << " count] error: __thriftError]) return NO;" << endl;
-  }
-
-  string iter = tmp("_iter");
-  string key;
-  if (ttype->is_map()) {
-    key = tmp("key");
-    indent(out) << "NSEnumerator * " << iter << " = [" << fieldName << " keyEnumerator];" << endl;
-    indent(out) << "id " << key << ";" << endl;
-    indent(out) << "while ((" << key << " = [" << iter << " nextObject]))" << endl;
-  } else if (ttype->is_set()) {
-    key = tmp("obj");
-    indent(out) << "NSEnumerator * " << iter << " = [" << fieldName << " objectEnumerator];"
-                << endl;
-    indent(out) << "id " << key << ";" << endl;
-    indent(out) << "while ((" << key << " = [" << iter << " nextObject]))" << endl;
-  } else if (ttype->is_list()) {
-    key = tmp("idx");
-    indent(out) << "int " << key << ";" << endl;
-    indent(out) << "for (" << key << " = 0; " << key << " < [" << fieldName << " count]; " << key
-                << "++)" << endl;
-  }
-
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    generate_serialize_map_element(out, (t_map*)ttype, key, fieldName);
-  } else if (ttype->is_set()) {
-    generate_serialize_set_element(out, (t_set*)ttype, key);
-  } else if (ttype->is_list()) {
-    generate_serialize_list_element(out, (t_list*)ttype, key, fieldName);
-  }
-
-  scope_down(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "if (![outProtocol writeMapEnd: __thriftError]) return NO;" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "if (![outProtocol writeSetEnd: __thriftError]) return NO;" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "if (![outProtocol writeListEnd: __thriftError]) return NO;" << endl;
-  }
-
-  scope_down(out);
-}
-
-/**
- * Serializes the members of a map.
- */
-void t_cocoa_generator::generate_serialize_map_element(ostream& out,
-                                                       t_map* tmap,
-                                                       string key,
-                                                       string mapName) {
-  t_field kfield(tmap->get_key_type(), key);
-  generate_serialize_field(out, &kfield, unbox(kfield.get_type(), key));
-  t_field vfield(tmap->get_val_type(), "[" + mapName + " objectForKey: " + key + "]");
-  generate_serialize_field(out, &vfield, unbox(vfield.get_type(), vfield.get_name()));
-}
-
-/**
- * Serializes the members of a set.
- */
-void t_cocoa_generator::generate_serialize_set_element(ostream& out,
-                                                       t_set* tset,
-                                                       string elementName) {
-  t_field efield(tset->get_elem_type(), elementName);
-  generate_serialize_field(out, &efield, unbox(efield.get_type(), elementName));
-}
-
-/**
- * Serializes the members of a list.
- */
-void t_cocoa_generator::generate_serialize_list_element(ostream& out,
-                                                        t_list* tlist,
-                                                        string index,
-                                                        string listName) {
-  t_field efield(tlist->get_elem_type(), "[" + listName + " objectAtIndex: " + index + "]");
-  generate_serialize_field(out, &efield, unbox(efield.get_type(), efield.get_name()));
-}
-
-/**
- * Returns an Objective-C name
- *
- * @param ttype The type
- * @param class_ref Do we want a Class reference istead of a type reference?
- * @return Objective-C type name, i.e. NSDictionary<Key,Value> *
- */
-string t_cocoa_generator::type_name(t_type* ttype, bool class_ref, bool needs_mutable) {
-  if (ttype->is_typedef()) {
-    string name = (needs_mutable && ttype->get_true_type()->is_container()) ? "Mutable" + ttype->get_name() : ttype->get_name();
-    t_program* program = ttype->get_program();
-    return program ? (program->get_namespace("cocoa") + name) : name;
-  }
-
-  string result;
-  if (ttype->is_base_type()) {
-    return base_type_name((t_base_type*)ttype);
-  } else if (ttype->is_enum()) {
-    return cocoa_prefix_ + ttype->get_name();
-  } else if (ttype->is_map()) {
-    t_map *map = (t_map *)ttype;
-    result = needs_mutable ? "NSMutableDictionary" : "NSDictionary";
-    result += "<" + element_type_name(map->get_key_type()) + ", " + element_type_name(map->get_val_type()) + ">";
-  } else if (ttype->is_set()) {
-    t_set *set = (t_set *)ttype;
-    result = needs_mutable ? "NSMutableSet" : "NSSet";
-    result += "<" + element_type_name(set->get_elem_type()) + ">";
-  } else if (ttype->is_list()) {
-    t_list *list = (t_list *)ttype;
-    result = needs_mutable ? "NSMutableArray" : "NSArray";
-    result += "<" + element_type_name(list->get_elem_type()) + ">";
-  } else {
-    // Check for prefix
-    t_program* program = ttype->get_program();
-    if (program != NULL) {
-      result = program->get_namespace("cocoa") + ttype->get_name();
-    } else {
-      result = ttype->get_name();
-    }
-  }
-
-  if (!class_ref) {
-    result += " *";
-  }
-  return result;
-}
-
-/**
- * Returns an Objective-C type name for container types
- *
- * @param ttype the type
- */
-string t_cocoa_generator::element_type_name(t_type* etype) {
-
-  t_type* ttype = etype->get_true_type();
-
-  if (etype->is_typedef() && type_can_be_null(ttype)) {
-    return type_name(etype);
-  }
-
-  string result;
-  if (ttype->is_base_type()) {
-    t_base_type* tbase = (t_base_type*)ttype;
-    switch (tbase->get_base()) {
-    case t_base_type::TYPE_STRING:
-      if (tbase->is_binary()) {
-        result = "NSData *";
-      }
-      else {
-        result = "NSString *";
-      }
-      break;
-    default:
-      result = "NSNumber *";
-      break;
-    }
-  } else if (ttype->is_enum()) {
-      result = "NSNumber *";
-  } else if (ttype->is_map()) {
-    t_map *map = (t_map *)ttype;
-    result = "NSDictionary<" + element_type_name(map->get_key_type()) + ", " + element_type_name(map->get_val_type()) + "> *";
-  } else if (ttype->is_set()) {
-    t_set *set = (t_set *)ttype;
-    result = "NSSet<" + element_type_name(set->get_elem_type()) + "> *";
-  } else if (ttype->is_list()) {
-    t_list *list = (t_list *)ttype;
-    result = "NSArray<" + element_type_name(list->get_elem_type()) + "> *";
-  } else if (ttype->is_struct() || ttype->is_xception()) {
-    result = cocoa_prefix_ + ttype->get_name() + " *";
-  }
-
-  return result;
-}
-
-/**
- * Returns the Objective-C type that corresponds to the thrift type.
- *
- * @param tbase The base type
- */
-string t_cocoa_generator::base_type_name(t_base_type* type) {
-  t_base_type::t_base tbase = type->get_base();
-
-  switch (tbase) {
-  case t_base_type::TYPE_VOID:
-    return "void";
-  case t_base_type::TYPE_STRING:
-    if (type->is_binary()) {
-      return "NSData *";
-    } else {
-      return "NSString *";
-    }
-  case t_base_type::TYPE_BOOL:
-    return "BOOL";
-  case t_base_type::TYPE_I8:
-    return "SInt8";
-  case t_base_type::TYPE_I16:
-    return "SInt16";
-  case t_base_type::TYPE_I32:
-    return "SInt32";
-  case t_base_type::TYPE_I64:
-    return "SInt64";
-  case t_base_type::TYPE_DOUBLE:
-    return "double";
-  default:
-    throw "compiler error: no Objective-C name for base type " + t_base_type::t_base_name(tbase);
-  }
-}
-
-/**
- * Prints the value of a constant with the given type. Note that type checking
- * is NOT performed in this function as it is always run beforehand using the
- * validate_types method in main.cc
- */
-void t_cocoa_generator::print_const_value(ostream& out,
-                                          string name,
-                                          t_type* type,
-                                          t_const_value* value,
-                                          bool defval) {
-  type = get_true_type(type);
-
-  if (type->is_base_type()) {
-    string v2 = render_const_value(out, type, value);
-    indent(out);
-    if (defval)
-      out << type_name(type) << " ";
-    out << name << " = " << v2 << ";" << endl << endl;
-  } else if (type->is_enum()) {
-    indent(out);
-    if (defval)
-      out << type_name(type) << " ";
-    out << name << " = " << render_const_value(out, type, value) << ";" << endl << endl;
-  } else if (type->is_struct() || type->is_xception()) {
-    indent(out);
-    const vector<t_field*>& fields = ((t_struct*)type)->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    if (defval)
-      out << type_name(type) << " ";
-    out << name << " = [" << type_name(type, true) << " new];"
-        << endl;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      t_type* field_type = NULL;
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field_type = (*f_iter)->get_type();
-        }
-      }
-      if (field_type == NULL) {
-        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
-      }
-      string val = render_const_value(out, field_type, v_iter->second);
-      std::string cap_name = capitalize(v_iter->first->get_string());
-      indent(out) << "[" << name << " set" << cap_name << ":" << val << "];" << endl;
-    }
-  } else if (type->is_map()) {
-    ostringstream mapout;
-    indent(mapout);
-    t_type* ktype = ((t_map*)type)->get_key_type();
-    t_type* vtype = ((t_map*)type)->get_val_type();
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    if (defval)
-      mapout << type_name(type) << " ";
-    mapout << name << " = @{";
-    for (v_iter = val.begin(); v_iter != val.end();) {
-      mapout << render_const_value(out, ktype, v_iter->first, true) << ": "
-          << render_const_value(out, vtype, v_iter->second, true);
-      if (++v_iter != val.end()) {
-        mapout << ", ";
-      }
-    }
-    mapout << "}";
-    out << mapout.str();
-  } else if (type->is_list()) {
-    ostringstream listout;
-    indent(listout);
-    t_type* etype = ((t_list*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    if (defval)
-      listout << type_name(type) << " ";
-    listout << name << " = @[";
-    for (v_iter = val.begin(); v_iter != val.end();) {
-      listout << render_const_value(out, etype, *v_iter, true);
-      if (++v_iter != val.end()) {
-        listout << ", ";
-      }
-    }
-    listout << "]";
-    out << listout.str();
-  } else if (type->is_set()) {
-    ostringstream setout;
-    indent(setout);
-    t_type* etype = ((t_set*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    if (defval)
-      setout << type_name(type) << " ";
-    setout << name << " = [NSSet setWithArray:@[";
-    for (v_iter = val.begin(); v_iter != val.end();) {
-      setout << render_const_value(out, etype, *v_iter, true);
-      if (++v_iter != val.end()) {
-        setout << ", ";
-      }
-    }
-    setout << "]]";
-    out << setout.str();
-  } else {
-    throw "compiler error: no const of type " + type->get_name();
-  }
-}
-
-string t_cocoa_generator::render_const_value(ostream& out,
-                                             t_type* type,
-                                             t_const_value* value,
-                                             bool box_it) {
-  type = get_true_type(type);
-  std::ostringstream render;
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      // We must handle binary constant but the syntax of IDL defines
-      // nothing about binary constant.
-      //   if type->is_binary())
-      //      // binary code
-      render << "@\"" << get_escaped_string(value) << '"';
-      break;
-    case t_base_type::TYPE_BOOL:
-      render << ((value->get_integer() > 0) ? "YES" : "NO");
-      break;
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-    case t_base_type::TYPE_I64:
-      render << value->get_integer();
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      if (value->get_type() == t_const_value::CV_INTEGER) {
-        render << value->get_integer();
-      } else {
-        render << value->get_double();
-      }
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else if (type->is_enum()) {
-    render << value->get_integer();
-  } else {
-    string t = tmp("tmp");
-    print_const_value(out, t, type, value, true);
-    out << ";" << endl;
-    render << t;
-  }
-
-  if (box_it) {
-    return box(type, render.str());
-  }
-  return render.str();
-}
-
-#if 0
-/**
-ORIGINAL
- * Spit out code that evaluates to the specified constant value.
- */
-string t_cocoa_generator::render_const_value(string name,
-                                             t_type* type,
-                                             t_const_value* value,
-                                             bool box_it) {
-  type = get_true_type(type);
-  std::ostringstream render;
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      render << "@\"" << get_escaped_string(value) << '"';
-      break;
-    case t_base_type::TYPE_BOOL:
-      render << ((value->get_integer() > 0) ? "YES" : "NO");
-      break;
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-    case t_base_type::TYPE_I64:
-      render << value->get_integer();
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      if (value->get_type() == t_const_value::CV_INTEGER) {
-        render << value->get_integer();
-      } else {
-        render << value->get_double();
-      }
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else if (type->is_enum()) {
-    render << value->get_integer();
-  } else if (type->is_struct() || type->is_xception()) {
-    const vector<t_field*>& fields = ((t_struct*)type)->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    if (val.size() > 0)
-      render << "[[" << type_name(type, true) << " alloc] initWith";
-    else
-      render << "[[" << type_name(type, true) << " alloc] init";
-    bool first = true;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      // FIXME The generated code does not match with initWithXXX
-      //       initializer and causes compile error.
-      //       Try: test/DebugProtoTest.thrift and test/SmallTest.thrift
-      t_type* field_type = NULL;
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field_type = (*f_iter)->get_type();
-        }
-      }
-      if (field_type == NULL) {
-        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
-      }
-      if (first) {
-        render << capitalize(v_iter->first->get_string());
-        first = false;
-      } else {
-        render << " " << v_iter->first->get_string();
-      }
-      render << ": " << render_const_value(name, field_type, v_iter->second);
-    }
-    render << "]";
-  } else if (type->is_map()) {
-    render << "[[NSDictionary alloc] initWithObjectsAndKeys: ";
-    t_type* ktype = ((t_map*)type)->get_key_type();
-    t_type* vtype = ((t_map*)type)->get_val_type();
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    bool first = true;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string key = render_const_value(name, ktype, v_iter->first, true);
-      string val = render_const_value(name, vtype, v_iter->second, true);
-      if (first) {
-        first = false;
-      } else {
-        render << ", ";
-      }
-      render << val << ", " << key;
-    }
-    if (first)
-      render << " nil]";
-    else
-      render << ", nil]";
-  } else if (type->is_list()) {
-    render << "[[NSArray alloc] initWithObjects: ";
-    t_type * etype = ((t_list*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    bool first = true;
-    vector<t_const_value*>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      if (first) {
-        first = false;
-      } else {
-        render << ", ";
-      }
-      render << render_const_value(name, etype, *v_iter, true);
-    }
-    if (first)
-      render << " nil]";
-    else
-      render << ", nil]";
-  } else if (type->is_set()) {
-    render << "[[NSSet alloc] initWithObjects: ";
-    t_type * etype = ((t_set*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    bool first = true;
-    vector<t_const_value*>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      if (first) {
-        first = false;
-      } else {
-        render << ", ";
-      }
-      render << render_const_value(name, etype, *v_iter, true);
-    }
-    if (first)
-      render << " nil]";
-    else
-      render << ", nil]";
-  } else {
-    throw "don't know how to render constant for type: " + type->get_name();
-  }
-
-  if (box_it) {
-    return box(type, render.str());
-  }
-
-  return render.str();
-}
-#endif
-
-/**
- * Declares an Objective-C 2.0 property.
- *
- * @param tfield The field to declare a property for
- */
-string t_cocoa_generator::declare_property(t_field* tfield) {
-  std::ostringstream render;
-  render << "@property (";
-
-  if (type_can_be_copy(tfield->get_type())) {
-    render << "copy, ";
-  } else if (type_can_be_null(tfield->get_type())) {
-    render << "strong, ";
-  } else {
-    render << "assign, ";
-  }
-
-  render << "nonatomic) " << type_name(tfield->get_type(), false, true) << " "
-  << tfield->get_name() << ";";
-
-  // Check if the property name is an Objective-C return +1 count signal
-  if ((tfield->get_name().length() >= 3 && tfield->get_name().substr(0,3) == "new") ||
-      (tfield->get_name().length() >= 6 && tfield->get_name().substr(0,6) == "create") ||
-      (tfield->get_name().length() >= 5 && tfield->get_name().substr(0,5) == "alloc")) {
-    // Let Objective-C know not to return +1 for object pointers
-    if (type_can_be_null(tfield->get_type())) {
-      render << endl;
-      render << "- (" + type_name(tfield->get_type()) + ") " + decapitalize(tfield->get_name()) + " __attribute__((objc_method_family(none)));";
-    }
-  }
-
-  return render.str();
-}
-
-/**
- * Declares an Objective-C 2.0 property.
- *
- * @param tfield The field to declare a property for
- */
-string t_cocoa_generator::declare_property_isset(t_field* tfield) {
-  return "@property (assign, nonatomic) BOOL " + decapitalize(tfield->get_name()) + "IsSet;";
-}
-
-/**
- * Declares property unset method.
- *
- * @param tfield The field to declare a property for
- */
-string t_cocoa_generator::declare_property_unset(t_field* tfield) {
-  return "- (void) unset" + capitalize(tfield->get_name()) + ";";
-}
-
-/**
- * Renders the early out return statement
- *
- * @param tfunction Function definition
- * @return String of rendered invalid return statment
- */
-string t_cocoa_generator::invalid_return_statement(t_function *tfunction) {
-  if ((tfunction->get_returntype()->is_void())) {
-    return "return NO;";
-  }
-  return "return nil;";
-}
-
-/**
- * Renders a function signature
- *
- * @param tfunction Function definition
- * @return String of rendered function definition
- */
-string t_cocoa_generator::function_signature(t_function* tfunction, bool include_error) {
-  t_type* ttype = tfunction->get_returntype();
-  string result;
-  if (ttype->is_void()) {
-    result = "(BOOL)";
-  }
-  else if (type_can_be_null(ttype)) {
-    result = "(" + type_name(ttype) + ")";
-  }
-  else {
-    result = "(NSNumber *)";
-  }
-  result += " " + tfunction->get_name() + argument_list(tfunction->get_arglist(), "", include_error);
-  return result;
-}
-
-/**
- * Renders a function signature that returns asynchronously instead of
- * literally returning.
- *
- * @param tfunction Function definition
- * @return String of rendered function definition
- */
-string t_cocoa_generator::async_function_signature(t_function* tfunction, bool include_error) {
-  t_type* ttype = tfunction->get_returntype();
-  t_struct* targlist = tfunction->get_arglist();
-  string response_param = "void (^)(" + ((ttype->is_void()) ? "" : type_name(ttype)) + ")";
-  std::string result = "(void) " + tfunction->get_name() + argument_list(tfunction->get_arglist(), "", include_error)
-  + (targlist->get_members().size() ? " response" : "") + ": ("
-  + response_param + ") responseBlock "
-  + "failure : (TAsyncFailureBlock) failureBlock";
-  return result;
-}
-
-/**
- * Renders a function signature that returns a promise instead of
- * literally returning.
- *
- * @param tfunction Function definition
- * @return String of rendered function definition
- */
-string t_cocoa_generator::promise_function_signature(t_function* tfunction) {
-  return "(AnyPromise *) " + tfunction->get_name() + argument_list(tfunction->get_arglist(), "", false);
-}
-
-/**
- * Renders a colon separated list of types and names, suitable for an
- * objective-c parameter list
- */
-string t_cocoa_generator::argument_list(t_struct* tstruct, string protocol_name, bool include_error) {
-  string result = "";
-  bool include_protocol = !protocol_name.empty();
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    string argPrefix = "";
-    if (first) {
-      first = false;
-    } else {
-      argPrefix = (*f_iter)->get_name();
-      result += " ";
-    }
-    result += argPrefix + ": (" + type_name((*f_iter)->get_type()) + ") " + (*f_iter)->get_name();
-  }
-  if (include_protocol) {
-    if (!first) {
-      result += " protocol";
-    }
-    result += ": (id<TProtocol>) " + protocol_name;
-    first = false;
-  }
-  if (include_error) {
-    if (!first) {
-      result += " error";
-    }
-    result += ": (NSError *__autoreleasing *)__thriftError";
-    first = false;
-  }
-  return result;
-}
-
-/**
- * Converts the parse type to an Objective-C enum string for the given type.
- */
-string t_cocoa_generator::type_to_enum(t_type* type) {
-  type = get_true_type(type);
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "NO T_VOID CONSTRUCT";
-    case t_base_type::TYPE_STRING:
-      return "TTypeSTRING";
-    case t_base_type::TYPE_BOOL:
-      return "TTypeBOOL";
-    case t_base_type::TYPE_I8:
-      return "TTypeBYTE";
-    case t_base_type::TYPE_I16:
-      return "TTypeI16";
-    case t_base_type::TYPE_I32:
-      return "TTypeI32";
-    case t_base_type::TYPE_I64:
-      return "TTypeI64";
-    case t_base_type::TYPE_DOUBLE:
-      return "TTypeDOUBLE";
-    }
-  } else if (type->is_enum()) {
-    return "TTypeI32";
-  } else if (type->is_struct() || type->is_xception()) {
-    return "TTypeSTRUCT";
-  } else if (type->is_map()) {
-    return "TTypeMAP";
-  } else if (type->is_set()) {
-    return "TTypeSET";
-  } else if (type->is_list()) {
-    return "TTypeLIST";
-  }
-
-  throw "INVALID TYPE IN type_to_enum: " + type->get_name();
-}
-
-/**
- * Returns a format string specifier for the supplied parse type.
- */
-string t_cocoa_generator::format_string_for_type(t_type* type) {
-  type = get_true_type(type);
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "NO T_VOID CONSTRUCT";
-    case t_base_type::TYPE_STRING:
-      return "\\\"%@\\\"";
-    case t_base_type::TYPE_BOOL:
-      return "%i";
-    case t_base_type::TYPE_I8:
-      return "%i";
-    case t_base_type::TYPE_I16:
-      return "%hi";
-    case t_base_type::TYPE_I32:
-      return "%i";
-    case t_base_type::TYPE_I64:
-      return "%qi";
-    case t_base_type::TYPE_DOUBLE:
-      return "%f";
-    }
-  } else if (type->is_enum()) {
-    return "%i";
-  } else if (type->is_struct() || type->is_xception()) {
-    return "%@";
-  } else if (type->is_map()) {
-    return "%@";
-  } else if (type->is_set()) {
-    return "%@";
-  } else if (type->is_list()) {
-    return "%@";
-  }
-
-  throw "INVALID TYPE IN format_string_for_type: " + type->get_name();
-}
-
-/**
- * Returns a format cast for the supplied parse type.
- */
-string t_cocoa_generator::format_cast_for_type(t_type* type) {
-  type = get_true_type(type);
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "NO T_VOID CONSTRUCT";
-    case t_base_type::TYPE_STRING:
-      return ""; // "\\\"%@\\\"";
-    case t_base_type::TYPE_BOOL:
-      return ""; // "%i";
-    case t_base_type::TYPE_I8:
-      return ""; // "%i";
-    case t_base_type::TYPE_I16:
-      return ""; // "%hi";
-    case t_base_type::TYPE_I32:
-      return "(int)"; // "%i";
-    case t_base_type::TYPE_I64:
-      return ""; // "%qi";
-    case t_base_type::TYPE_DOUBLE:
-      return ""; // "%f";
-    }
-  } else if (type->is_enum()) {
-    return "(int)"; // "%i";
-  } else if (type->is_struct() || type->is_xception()) {
-    return ""; // "%@";
-  } else if (type->is_map()) {
-    return ""; // "%@";
-  } else if (type->is_set()) {
-    return ""; // "%@";
-  } else if (type->is_list()) {
-    return ""; // "%@";
-  }
-
-  throw "INVALID TYPE IN format_cast_for_type: " + type->get_name();
-}
-
-/**
- * Generate a call to a field's setter.
- *
- * @param tfield Field the setter is being called on
- * @param fieldName Name of variable to pass to setter
- */
-
-string t_cocoa_generator::call_field_setter(t_field* tfield, string fieldName) {
-  return "self." + tfield->get_name() + " = " + fieldName + ";";
-}
-
-THRIFT_REGISTER_GENERATOR(
-    cocoa,
-    "Cocoa",
-    "    log_unexpected:  Log every time an unexpected field ID or type is encountered.\n"
-    "    debug_descriptions:\n"
-    "                     Allow use of debugDescription so the app can add description via a cateogory/extension\n"
-    "    validate_required:\n"
-    "                     Throws exception if any required field is not set.\n"
-    "    async_clients:   Generate clients which invoke asynchronously via block syntax.\n"
-    "    pods:            Generate imports in Cocopods framework format.\n"
-    "    promise_kit:     Generate clients which invoke asynchronously via promises.\n")
+/* 
+ * Licensed to the Apache Software Foundation (ASF) under one 
+ * or more contributor license agreements. See the NOTICE file 
+ * distributed with this work for additional information 
+ * regarding copyright ownership. The ASF licenses this file 
+ * to you under the Apache License, Version 2.0 (the 
+ * "License"); you may not use this file except in compliance 
+ * with the License. You may obtain a copy of the License at 
+ * 
+ *   http://www.apache.org/licenses/LICENSE-2.0 
+ * 
+ * Unless required by applicable law or agreed to in writing, 
+ * software distributed under the License is distributed on an 
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY 
+ * KIND, either express or implied. See the License for the 
+ * specific language governing permissions and limitations 
+ * under the License. 
+ */ 
+ 
+#include <string> 
+#include <fstream> 
+#include <iostream> 
+#include <vector> 
+ 
+#include <stdlib.h> 
+#include <sys/stat.h> 
+#include <sstream> 
+#include "thrift/platform.h" 
+#include "thrift/generate/t_oop_generator.h" 
+ 
+using std::map; 
+using std::ostream; 
+using std::ofstream; 
+using std::ostringstream; 
+using std::string; 
+using std::stringstream; 
+using std::vector; 
+ 
+static const string endl = "\n"; // avoid ostream << std::endl flushes 
+ 
+/** 
+ * Objective-C code generator. 
+ * 
+ * mostly copy/pasting/tweaking from mcslee's work. 
+ */ 
+class t_cocoa_generator : public t_oop_generator { 
+public: 
+  t_cocoa_generator(t_program* program, 
+                    const std::map<std::string, std::string>& parsed_options, 
+                    const std::string& option_string) 
+    : t_oop_generator(program) { 
+    (void)option_string; 
+    std::map<std::string, std::string>::const_iterator iter; 
+ 
+    log_unexpected_ = false; 
+    validate_required_ = false; 
+    async_clients_ = false; 
+    promise_kit_ = false; 
+    debug_descriptions_ = false; 
+    pods_ = false; 
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) { 
+      if( iter->first.compare("log_unexpected") == 0) { 
+        log_unexpected_ = true; 
+      } else if( iter->first.compare("validate_required") == 0) { 
+        validate_required_ = true; 
+      } else if( iter->first.compare("async_clients") == 0) { 
+        async_clients_ = true; 
+      } else if( iter->first.compare("promise_kit") == 0) { 
+        promise_kit_ = true; 
+      } else if( iter->first.compare("debug_descriptions") == 0) { 
+        debug_descriptions_ = true; 
+      } else if( iter->first.compare("pods") == 0) { 
+        pods_ = true; 
+      } else { 
+        throw "unknown option cocoa:" + iter->first; 
+      } 
+    } 
+ 
+    out_dir_base_ = "gen-cocoa"; 
+  } 
+ 
+  /** 
+   * Init and close methods 
+   */ 
+ 
+  void init_generator(); 
+  void close_generator(); 
+ 
+  void generate_consts(std::vector<t_const*> consts); 
+ 
+  /** 
+   * Program-level generation functions 
+   */ 
+ 
+  void generate_typedef(t_typedef* ttypedef); 
+  void generate_enum(t_enum* tenum); 
+  void generate_struct(t_struct* tstruct); 
+  void generate_xception(t_struct* txception); 
+  void generate_service(t_service* tservice); 
+ 
+  void print_const_value(ostream& out, 
+                         string name, 
+                         t_type* type, 
+                         t_const_value* value, 
+                         bool defval = false); 
+  std::string render_const_value(ostream& out, 
+                                 t_type* type, 
+                                 t_const_value* value, 
+                                 bool box_it = false); 
+ 
+  void generate_cocoa_struct(t_struct* tstruct, bool is_exception); 
+  void generate_cocoa_struct_interface(std::ostream& out, 
+                                       t_struct* tstruct, 
+                                       bool is_xception = false); 
+  void generate_cocoa_struct_implementation(std::ostream& out, 
+                                            t_struct* tstruct, 
+                                            bool is_xception = false, 
+                                            bool is_result = false); 
+  void generate_cocoa_struct_initializer_signature(std::ostream& out, t_struct* tstruct); 
+  void generate_cocoa_struct_init_with_coder_method(ostream& out, 
+                                                    t_struct* tstruct, 
+                                                    bool is_exception); 
+  void generate_cocoa_struct_encode_with_coder_method(ostream& out, 
+                                                      t_struct* tstruct, 
+                                                      bool is_exception); 
+  void generate_cocoa_struct_copy_method(ostream& out, 
+                                         t_struct* tstruct, 
+                                         bool is_exception); 
+  void generate_cocoa_struct_hash_method(ostream& out, t_struct* tstruct); 
+  void generate_cocoa_struct_is_equal_method(ostream& out, 
+                                             t_struct* tstruct, 
+                                             bool is_exception); 
+  void generate_cocoa_struct_field_accessor_implementations(std::ostream& out, 
+                                                            t_struct* tstruct, 
+                                                            bool is_exception); 
+  void generate_cocoa_struct_reader(std::ostream& out, t_struct* tstruct); 
+  void generate_cocoa_struct_result_writer(std::ostream& out, t_struct* tstruct); 
+  void generate_cocoa_struct_writer(std::ostream& out, t_struct* tstruct); 
+  void generate_cocoa_struct_validator(std::ostream& out, t_struct* tstruct); 
+  void generate_cocoa_struct_description(std::ostream& out, t_struct* tstruct); 
+ 
+  std::string function_result_helper_struct_type(t_service *tservice, t_function* tfunction); 
+  std::string function_args_helper_struct_type(t_service* tservice, t_function* tfunction); 
+  void generate_function_helpers(t_service *tservice, t_function* tfunction); 
+ 
+  /** 
+   * Service-level generation functions 
+   */ 
+ 
+  void generate_cocoa_service_protocol(std::ostream& out, t_service* tservice); 
+  void generate_cocoa_service_async_protocol(std::ostream& out, t_service* tservice); 
+ 
+  void generate_cocoa_service_client_interface(std::ostream& out, t_service* tservice); 
+  void generate_cocoa_service_client_async_interface(std::ostream& out, t_service* tservice); 
+ 
+  void generate_cocoa_service_client_send_function_implementation(ostream& out, 
+                                                                  t_service* tservice, 
+                                                                  t_function* tfunction, 
+                                                                  bool needs_protocol); 
+  void generate_cocoa_service_client_send_function_invocation(ostream& out, t_function* tfunction); 
+  void generate_cocoa_service_client_send_async_function_invocation(ostream& out, 
+                                                                    t_function* tfunction, 
+                                                                    string failureBlockName); 
+  void generate_cocoa_service_client_recv_function_implementation(ostream& out, 
+                                                                  t_service* tservice, 
+                                                                  t_function* tfunction, 
+                                                                  bool needs_protocol); 
+  void generate_cocoa_service_client_implementation(std::ostream& out, t_service* tservice); 
+  void generate_cocoa_service_client_async_implementation(std::ostream& out, t_service* tservice); 
+ 
+  void generate_cocoa_service_server_interface(std::ostream& out, t_service* tservice); 
+  void generate_cocoa_service_server_implementation(std::ostream& out, t_service* tservice); 
+  void generate_cocoa_service_helpers(t_service* tservice); 
+  void generate_service_client(t_service* tservice); 
+  void generate_service_server(t_service* tservice); 
+  void generate_process_function(t_service* tservice, t_function* tfunction); 
+ 
+  /** 
+   * Serialization constructs 
+   */ 
+ 
+  void generate_deserialize_field(std::ostream& out, t_field* tfield, std::string fieldName); 
+ 
+  void generate_deserialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = ""); 
+ 
+  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+ 
+  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = ""); 
+ 
+  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = ""); 
+ 
+  void generate_deserialize_list_element(std::ostream& out, 
+                                         t_list* tlist, 
+                                         std::string prefix = ""); 
+ 
+  void generate_serialize_field(std::ostream& out, t_field* tfield, std::string prefix = ""); 
+ 
+  void generate_serialize_struct(std::ostream& out, t_struct* tstruct, std::string fieldName = ""); 
+ 
+  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+ 
+  void generate_serialize_map_element(std::ostream& out, 
+                                      t_map* tmap, 
+                                      std::string iter, 
+                                      std::string map); 
+ 
+  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter); 
+ 
+  void generate_serialize_list_element(std::ostream& out, 
+                                       t_list* tlist, 
+                                       std::string index, 
+                                       std::string listName); 
+ 
+  /** 
+   * Helper rendering functions 
+   */ 
+ 
+  std::string cocoa_prefix(); 
+  std::string cocoa_imports(); 
+  std::string cocoa_thrift_imports(); 
+  std::string type_name(t_type* ttype, bool class_ref = false, bool needs_mutable = false); 
+  std::string element_type_name(t_type* ttype); 
+  std::string base_type_name(t_base_type* tbase); 
+  std::string declare_property(t_field* tfield); 
+  std::string declare_property_isset(t_field* tfield); 
+  std::string declare_property_unset(t_field* tfield); 
+  std::string invalid_return_statement(t_function* tfunction); 
+  std::string function_signature(t_function* tfunction, bool include_error); 
+  std::string async_function_signature(t_function* tfunction, bool include_error); 
+  std::string promise_function_signature(t_function* tfunction); 
+  std::string argument_list(t_struct* tstruct, string protocol_name, bool include_error); 
+  std::string type_to_enum(t_type* ttype); 
+  std::string format_string_for_type(t_type* type); 
+  std::string format_cast_for_type(t_type* type); 
+  std::string call_field_setter(t_field* tfield, std::string fieldName); 
+  std::string box(t_type *ttype, std::string field_name); 
+  std::string unbox(t_type* ttype, std::string field_name); 
+  std::string getter_name(string field_name); 
+  std::string setter_name(string field_name); 
+ 
+  bool type_can_be_copy(t_type* ttype) { 
+    ttype = get_true_type(ttype); 
+     
+    return ttype->is_string(); 
+  } 
+   
+  bool type_can_be_null(t_type* ttype) { 
+    ttype = get_true_type(ttype); 
+ 
+    return ttype->is_container() || ttype->is_struct() || ttype->is_xception() 
+           || ttype->is_string(); 
+  } 
+ 
+private: 
+  std::string cocoa_prefix_; 
+  std::string constants_declarations_; 
+  int error_constant_; 
+ 
+  /** 
+   * File streams 
+   */ 
+ 
+  ofstream_with_content_based_conditional_update f_header_; 
+  ofstream_with_content_based_conditional_update f_impl_; 
+ 
+  bool log_unexpected_; 
+  bool validate_required_; 
+  bool async_clients_; 
+  bool promise_kit_; 
+  bool debug_descriptions_; 
+  bool pods_; 
+}; 
+ 
+/** 
+ * Prepares for file generation by opening up the necessary file output 
+ * streams. 
+ */ 
+void t_cocoa_generator::init_generator() { 
+  // Make output directory 
+  MKDIR(get_out_dir().c_str()); 
+  cocoa_prefix_ = program_->get_namespace("cocoa"); 
+ 
+  // we have a .h header file... 
+  string f_header_name = cocoa_prefix_ + capitalize(program_name_) + ".h"; 
+  string f_header_fullname = get_out_dir() + f_header_name; 
+  f_header_.open(f_header_fullname.c_str()); 
+ 
+  f_header_ << autogen_comment() << endl; 
+ 
+  f_header_ << cocoa_imports() << cocoa_thrift_imports(); 
+ 
+  // ...and a .m implementation file 
+  string f_impl_name = cocoa_prefix_ + capitalize(program_name_) + ".m"; 
+  string f_impl_fullname = get_out_dir() + f_impl_name; 
+  f_impl_.open(f_impl_fullname.c_str()); 
+ 
+  f_impl_ << autogen_comment() << endl; 
+ 
+  f_impl_ << cocoa_imports() << cocoa_thrift_imports() << "#import \"" << f_header_name << "\"" 
+          << endl << endl; 
+ 
+  error_constant_ = 60000; 
+} 
+ 
+/** 
+ * Prints standard Cocoa imports 
+ * 
+ * @return List of imports for Cocoa libraries 
+ */ 
+string t_cocoa_generator::cocoa_imports() { 
+  return string() + "#import <Foundation/Foundation.h>\n" + "\n"; 
+} 
+ 
+/** 
+ * Prints thrift runtime imports 
+ * 
+ * @return List of imports necessary for thrift runtime 
+ */ 
+string t_cocoa_generator::cocoa_thrift_imports() { 
+ 
+  vector<string> includes_list; 
+  includes_list.push_back("TProtocol.h"); 
+  includes_list.push_back("TProtocolFactory.h"); 
+  includes_list.push_back("TApplicationError.h"); 
+  includes_list.push_back("TProtocolError.h"); 
+  includes_list.push_back("TProtocolUtil.h"); 
+  includes_list.push_back("TProcessor.h"); 
+  includes_list.push_back("TBase.h"); 
+  includes_list.push_back("TAsyncTransport.h"); 
+  includes_list.push_back("TBaseClient.h"); 
+ 
+  std::ostringstream includes; 
+ 
+  vector<string>::const_iterator i_iter; 
+  for (i_iter=includes_list.begin(); i_iter!=includes_list.end(); ++i_iter) { 
+    includes << "#import "; 
+    if (pods_) { 
+      includes << "<Thrift/" << *i_iter << ">"; 
+    } else { 
+      includes << "\"" << *i_iter << "\""; 
+    } 
+    includes << endl; 
+  } 
+ 
+  includes << endl; 
+ 
+  if (promise_kit_) { 
+    includes << "#import "; 
+    if (pods_) { 
+      includes << "<PromiseKit/PromiseKit.h>"; 
+    } else { 
+      includes << "\"PromiseKit.h\""; 
+    } 
+    includes << endl; 
+  } 
+ 
+  // Include other Thrift includes 
+  const vector<t_program*>& other_includes = program_->get_includes(); 
+  for (size_t i = 0; i < other_includes.size(); ++i) { 
+    includes << "#import \"" 
+             << other_includes[i]->get_namespace("cocoa") 
+             << capitalize(other_includes[i]->get_name()) 
+             << ".h\"" << endl; 
+  } 
+ 
+  includes << endl; 
+ 
+  return includes.str(); 
+} 
+ 
+/** 
+ * Finish up generation. 
+ */ 
+void t_cocoa_generator::close_generator() { 
+  // stick our constants declarations at the end of the header file 
+  // since they refer to things we are defining. 
+  f_header_ << constants_declarations_ << endl; 
+} 
+ 
+/** 
+ * Generates a typedef. This is just a simple 1-liner in objective-c 
+ * 
+ * @param ttypedef The type definition 
+ */ 
+void t_cocoa_generator::generate_typedef(t_typedef* ttypedef) { 
+  if (ttypedef->get_type()->is_map()) { 
+    t_map *map = (t_map *)ttypedef->get_type(); 
+    if (map->get_key_type()->is_struct()) { 
+      f_header_ << indent() << "@class " << type_name(map->get_key_type(), true) << ";" << endl; 
+    } 
+    if (map->get_val_type()->is_struct()) { 
+      f_header_ << indent() << "@class " << type_name(map->get_val_type(), true) << ";" << endl; 
+    } 
+  } 
+  else if (ttypedef->get_type()->is_set()) { 
+    t_set *set = (t_set *)ttypedef->get_type(); 
+    if (set->get_elem_type()->is_struct()) { 
+      f_header_ << indent() << "@class " << type_name(set->get_elem_type(), true) << ";" << endl; 
+    } 
+  } 
+  else if (ttypedef->get_type()->is_list()) { 
+    t_list *list = (t_list *)ttypedef->get_type(); 
+    if (list->get_elem_type()->is_struct()) { 
+      f_header_ << indent() << "@class " << type_name(list->get_elem_type(), true) << ";" << endl; 
+    } 
+  } 
+  f_header_ << indent() << "typedef " << type_name(ttypedef->get_type()) << " " << cocoa_prefix_ 
+            << ttypedef->get_symbolic() << ";" << endl << endl; 
+  if (ttypedef->get_type()->is_container()) { 
+    f_header_ << indent() << "typedef " << type_name(ttypedef->get_type(), false, true) << " " << cocoa_prefix_ 
+              << "Mutable" << ttypedef->get_symbolic() << ";" << endl << endl; 
+  } 
+} 
+ 
+/** 
+ * Generates code for an enumerated type. In Objective-C, this is 
+ * essentially the same as the thrift definition itself, instead using 
+ * NS_ENUM keyword in Objective-C.  For namespace purposes, the name of 
+ * the enum is prefixed to each element in keeping with Cocoa & Swift 
+ * standards. 
+ * 
+ * @param tenum The enumeration 
+ */ 
+void t_cocoa_generator::generate_enum(t_enum* tenum) { 
+  f_header_ << indent() << "typedef NS_ENUM(SInt32, " << cocoa_prefix_ << tenum->get_name() << ") {" << endl; 
+  indent_up(); 
+ 
+  vector<t_enum_value*> constants = tenum->get_constants(); 
+  vector<t_enum_value*>::iterator c_iter; 
+  bool first = true; 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      f_header_ << "," << endl; 
+    } 
+    f_header_ << indent() << cocoa_prefix_ << tenum->get_name() << (*c_iter)->get_name(); 
+    f_header_ << " = " << (*c_iter)->get_value(); 
+  } 
+ 
+  indent_down(); 
+  f_header_ << endl << "};" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a class that holds all the constants. 
+ */ 
+void t_cocoa_generator::generate_consts(std::vector<t_const*> consts) { 
+  std::ostringstream const_interface; 
+ 
+  const_interface << "FOUNDATION_EXPORT NSString *" << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain;" << endl 
+                  << endl; 
+ 
+ 
+  bool needs_class = false; 
+ 
+  // Public constants for base types & strings 
+  vector<t_const*>::iterator c_iter; 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    t_type* type = (*c_iter)->get_type()->get_true_type(); 
+    if (!type->is_container() && !type->is_struct()) { 
+      const_interface << "FOUNDATION_EXPORT " << type_name(type) << " " 
+                      << cocoa_prefix_ << capitalize((*c_iter)->get_name()) << ";" << endl; 
+    } 
+    else { 
+      needs_class = true; 
+    } 
+  } 
+ 
+ 
+  string constants_class_name = cocoa_prefix_ + capitalize(program_name_) + "Constants"; 
+ 
+  if (needs_class) { 
+ 
+    const_interface << endl; 
+ 
+    const_interface << "@interface " << constants_class_name << " : NSObject "; 
+    scope_up(const_interface); 
+    scope_down(const_interface); 
+ 
+    // getter method for each constant defined. 
+    for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+      string name = (*c_iter)->get_name(); 
+      t_type* type = (*c_iter)->get_type()->get_true_type(); 
+      if (type->is_container() || type->is_struct()) { 
+        t_type* type = (*c_iter)->get_type(); 
+        const_interface << endl << "+ (" << type_name(type) << ") " << name << ";" << endl; 
+      } 
+    } 
+ 
+    const_interface << endl << "@end"; 
+  } 
+ 
+  // this gets spit into the header file in ::close_generator 
+  constants_declarations_ = const_interface.str(); 
+ 
+  f_impl_ << "NSString *" << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain = " 
+          << "@\"" << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain\";" << endl << endl; 
+ 
+  // variables in the .m hold all simple constant values 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    string name = (*c_iter)->get_name(); 
+    t_type* type = (*c_iter)->get_type(); 
+    f_impl_ << type_name(type) << " " << cocoa_prefix_ << name; 
+    t_type* ttype = type->get_true_type(); 
+    if (!ttype->is_container() && !ttype->is_struct()) { 
+      f_impl_ << " = " << render_const_value(f_impl_, type, (*c_iter)->get_value()); 
+    } 
+    f_impl_ << ";" << endl; 
+  } 
+  f_impl_ << endl; 
+ 
+  if (needs_class) { 
+ 
+    f_impl_ << "@implementation " << constants_class_name << endl << endl; 
+ 
+    // initialize complex constants when the class is loaded 
+    f_impl_ << "+ (void) initialize "; 
+    scope_up(f_impl_); 
+ 
+    for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+      t_type* ttype = (*c_iter)->get_type()->get_true_type(); 
+      if (ttype->is_container() || ttype->is_struct()) { 
+        f_impl_ << endl; 
+        print_const_value(f_impl_, 
+                          cocoa_prefix_ + (*c_iter)->get_name(), 
+                          (*c_iter)->get_type(), 
+                          (*c_iter)->get_value(), 
+                          false); 
+        f_impl_ << ";" << endl; 
+      } 
+    } 
+    scope_down(f_impl_); 
+ 
+    // getter method for each constant 
+    for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+      string name = (*c_iter)->get_name(); 
+      t_type* type = (*c_iter)->get_type()->get_true_type(); 
+      if (type->is_container() || type->is_struct()) { 
+        f_impl_ << endl << "+ (" << type_name(type) << ") " << name << " "; 
+        scope_up(f_impl_); 
+        indent(f_impl_) << "return " << cocoa_prefix_ << name << ";" << endl; 
+        scope_down(f_impl_); 
+      } 
+    } 
+ 
+    f_impl_ << "@end" << endl << endl; 
+  } 
+} 
+ 
+/** 
+ * Generates a struct definition for a thrift data type. This is a class 
+ * with protected data members, read(), write(), and getters and setters. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_struct(t_struct* tstruct) { 
+  generate_cocoa_struct_interface(f_header_, tstruct, false); 
+  generate_cocoa_struct_implementation(f_impl_, tstruct, false); 
+} 
+ 
+/** 
+ * Exceptions are structs, but they inherit from NSException 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_xception(t_struct* txception) { 
+  generate_cocoa_struct_interface(f_header_, txception, true); 
+  generate_cocoa_struct_implementation(f_impl_, txception, true); 
+} 
+ 
+/** 
+ * Generate the interface for a struct 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_interface(ostream& out, 
+                                                        t_struct* tstruct, 
+                                                        bool is_exception) { 
+ 
+  if (is_exception) { 
+    out << "enum {" << endl 
+        << "  " << cocoa_prefix_ << capitalize(program_name_) << "Error" << tstruct->get_name() <<  " = -" << error_constant_++ << endl 
+        << "};" << endl 
+        << endl; 
+  } 
+ 
+  out << "@interface " << cocoa_prefix_ << tstruct->get_name() << " : "; 
+ 
+  if (is_exception) { 
+    out << "NSError "; 
+  } else { 
+    out << "NSObject "; 
+  } 
+  out << "<TBase, NSCoding, NSCopying> " << endl; 
+ 
+  out << endl; 
+ 
+  // properties 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  if (members.size() > 0) { 
+    vector<t_field*>::const_iterator m_iter; 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      out << indent() << declare_property(*m_iter) << endl; 
+      out << indent() << declare_property_isset(*m_iter) << endl; 
+      out << indent() << declare_property_unset(*m_iter) << endl; 
+      out << endl; 
+    } 
+  } 
+ 
+  out << endl; 
+ 
+  // initializer for all fields 
+  if (!members.empty()) { 
+    generate_cocoa_struct_initializer_signature(out, tstruct); 
+    out << ";" << endl; 
+  } 
+  out << endl; 
+ 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generate signature for initializer of struct with a parameter for 
+ * each field. 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_initializer_signature(ostream& out, 
+                                                                    t_struct* tstruct) { 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+  indent(out) << "- (instancetype) initWith"; 
+  for (m_iter = members.begin(); m_iter != members.end();) { 
+    if (m_iter == members.begin()) { 
+      out << capitalize((*m_iter)->get_name()); 
+    } else { 
+      out << (*m_iter)->get_name(); 
+    } 
+    out << ": (" << type_name((*m_iter)->get_type()) << ") " << (*m_iter)->get_name(); 
+    ++m_iter; 
+    if (m_iter != members.end()) { 
+      out << " "; 
+    } 
+  } 
+} 
+ 
+/** 
+ * Generate the initWithCoder method for this struct so it's compatible with 
+ * the NSCoding protocol 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_init_with_coder_method(ostream& out, 
+                                                                     t_struct* tstruct, 
+                                                                     bool is_exception) { 
+ 
+  indent(out) << "- (instancetype) initWithCoder: (NSCoder *) decoder" << endl; 
+  scope_up(out); 
+ 
+  if (is_exception) { 
+    // NSExceptions conform to NSCoding, so we can call super 
+    indent(out) << "self = [super initWithCoder: decoder];" << endl; 
+  } else { 
+    indent(out) << "self = [super init];" << endl; 
+  } 
+ 
+  indent(out) << "if (self) "; 
+  scope_up(out); 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = get_true_type((*m_iter)->get_type()); 
+    out << indent() << "if ([decoder containsValueForKey: @\"" << (*m_iter)->get_name() << "\"])" 
+        << endl; 
+    scope_up(out); 
+    out << indent() << "_" << (*m_iter)->get_name() << " = "; 
+    if (type_can_be_null(t)) { 
+      out << "[decoder decodeObjectForKey: @\"" << (*m_iter)->get_name() << "\"];" 
+          << endl; 
+    } else if (t->is_enum()) { 
+      out << "[decoder decodeIntForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl; 
+    } else { 
+      t_base_type::t_base tbase = ((t_base_type*)t)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_BOOL: 
+        out << "[decoder decodeBoolForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "[decoder decodeIntForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "[decoder decodeIntForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "[decoder decodeInt32ForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "[decoder decodeInt64ForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "[decoder decodeDoubleForKey: @\"" << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      default: 
+        throw "compiler error: don't know how to decode thrift type: " 
+            + t_base_type::t_base_name(tbase); 
+      } 
+    } 
+    out << indent() << "_" << (*m_iter)->get_name() << "IsSet = YES;" << endl; 
+    scope_down(out); 
+  } 
+ 
+  scope_down(out); 
+ 
+  out << indent() << "return self;" << endl; 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+/** 
+ * Generate the encodeWithCoder method for this struct so it's compatible with 
+ * the NSCoding protocol 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_encode_with_coder_method(ostream& out, 
+                                                                       t_struct* tstruct, 
+                                                                       bool is_exception) { 
+ 
+  indent(out) << "- (void) encodeWithCoder: (NSCoder *) encoder" << endl; 
+  scope_up(out); 
+ 
+  if (is_exception) { 
+    // NSExceptions conform to NSCoding, so we can call super 
+    out << indent() << "[super encodeWithCoder: encoder];" << endl; 
+  } 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = get_true_type((*m_iter)->get_type()); 
+    out << indent() << "if (_" << (*m_iter)->get_name() << "IsSet)" << endl; 
+    scope_up(out); 
+    if (type_can_be_null(t)) { 
+      out << indent() << "[encoder encodeObject: _" << (*m_iter)->get_name() << " forKey: @\"" 
+          << (*m_iter)->get_name() << "\"];" << endl; 
+    } else if (t->is_enum()) { 
+      out << indent() << "[encoder encodeInt: _" << (*m_iter)->get_name() << " forKey: @\"" 
+          << (*m_iter)->get_name() << "\"];" << endl; 
+    } else { 
+      t_base_type::t_base tbase = ((t_base_type*)t)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_BOOL: 
+        out << indent() << "[encoder encodeBool: _" << (*m_iter)->get_name() << " forKey: @\"" 
+            << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << indent() << "[encoder encodeInt: _" << (*m_iter)->get_name() << " forKey: @\"" 
+            << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << indent() << "[encoder encodeInt: _" << (*m_iter)->get_name() << " forKey: @\"" 
+            << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << indent() << "[encoder encodeInt32: _" << (*m_iter)->get_name() << " forKey: @\"" 
+            << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << indent() << "[encoder encodeInt64: _" << (*m_iter)->get_name() << " forKey: @\"" 
+            << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << indent() << "[encoder encodeDouble: _" << (*m_iter)->get_name() << " forKey: @\"" 
+            << (*m_iter)->get_name() << "\"];" << endl; 
+        break; 
+      default: 
+        throw "compiler error: don't know how to encode thrift type: " 
+            + t_base_type::t_base_name(tbase); 
+      } 
+    } 
+    scope_down(out); 
+  } 
+ 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+/** 
+ * Generate the copy method for this struct 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_copy_method(ostream& out, t_struct* tstruct, bool is_exception) { 
+  out << indent() << "- (instancetype) copyWithZone:(NSZone *)zone" << endl; 
+  scope_up(out); 
+ 
+  if (is_exception) { 
+    out << indent() << type_name(tstruct) << " val = [" << cocoa_prefix_ << tstruct->get_name() << " errorWithDomain: self.domain code: self.code userInfo: self.userInfo];" << endl; 
+  } else { 
+    out << indent() << type_name(tstruct) << " val = [" << cocoa_prefix_ << tstruct->get_name() << " new];" << endl; 
+  } 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = get_true_type((*m_iter)->get_type()); 
+    out << indent() << "if (_" << (*m_iter)->get_name() << "IsSet)" << endl; 
+    scope_up(out); 
+    if (type_can_be_null(t)) { 
+      out << indent() << "val." << (*m_iter)->get_name() << " = [self." << (*m_iter)->get_name() << " copy];"; 
+    } else { 
+      out << indent() << "val." << (*m_iter)->get_name() << " = self." << (*m_iter)->get_name() << ";"; 
+    } 
+    out << endl; 
+    scope_down(out); 
+  } 
+ 
+  out << indent() << "return val;" << endl; 
+ 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+/** 
+ * Generate the hash method for this struct 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_hash_method(ostream& out, t_struct* tstruct) { 
+  indent(out) << "- (NSUInteger) hash" << endl; 
+  scope_up(out); 
+  out << indent() << "NSUInteger hash = 17;" << endl; 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = get_true_type((*m_iter)->get_type()); 
+    out << indent() << "hash = (hash * 31) ^ _" << (*m_iter)->get_name() 
+        << "IsSet ? 2654435761 : 0;" << endl; 
+    out << indent() << "if (_" << (*m_iter)->get_name() << "IsSet)" << endl; 
+    scope_up(out); 
+    if (type_can_be_null(t)) { 
+      out << indent() << "hash = (hash * 31) ^ [_" << (*m_iter)->get_name() << " hash];" << endl; 
+    } else { 
+      out << indent() << "hash = (hash * 31) ^ [@(_" << (*m_iter)->get_name() << ") hash];" 
+          << endl; 
+    } 
+    scope_down(out); 
+  } 
+ 
+  out << indent() << "return hash;" << endl; 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+/** 
+ * Generate the isEqual method for this struct 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_is_equal_method(ostream& out, t_struct* tstruct, bool is_exception) { 
+  indent(out) << "- (BOOL) isEqual: (id) anObject" << endl; 
+  scope_up(out); 
+ 
+  indent(out) << "if (self == anObject) {" << endl; 
+  indent_up(); 
+  indent(out) << "return YES;" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+ 
+  string class_name = cocoa_prefix_ + tstruct->get_name(); 
+ 
+  if (is_exception) { 
+    indent(out) << "if (![super isEqual:anObject]) {" << endl; 
+    indent_up(); 
+    indent(out) << "return NO;" << endl; 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+  } 
+  else { 
+    indent(out) << "if (![anObject isKindOfClass:[" << class_name << " class]]) {" << endl; 
+    indent_up(); 
+    indent(out) << "return NO;" << endl; 
+    indent_down(); 
+    indent(out) << "}" << endl; 
+  } 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  if (!members.empty()) { 
+    indent(out) << class_name << " *other = (" << class_name << " *)anObject;" << endl; 
+ 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      t_type* t = get_true_type((*m_iter)->get_type()); 
+      string name = (*m_iter)->get_name(); 
+      if (type_can_be_null(t)) { 
+        out << indent() << "if ((_" << name << "IsSet != other->_" << name << "IsSet) ||" << endl 
+            << indent() << "    " 
+            << "(_" << name << "IsSet && " 
+            << "((_" << name << " || other->_" << name << ") && " 
+            << "![_" << name << " isEqual:other->_" << name << "]))) {" << endl; 
+      } else { 
+        out << indent() << "if ((_" << name << "IsSet != other->_" << name << "IsSet) ||" << endl 
+            << indent() << "    " 
+            << "(_" << name << "IsSet && " 
+            << "(_" << name << " != other->_" << name << "))) {" << endl; 
+      } 
+      indent_up(); 
+      indent(out) << "return NO;" << endl; 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+  } 
+ 
+  out << indent() << "return YES;" << endl; 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+/** 
+ * Generate struct implementation. 
+ * 
+ * @param tstruct      The struct definition 
+ * @param is_exception Is this an exception? 
+ * @param is_result    If this is a result it needs a different writer 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_implementation(ostream& out, 
+                                                             t_struct* tstruct, 
+                                                             bool is_exception, 
+                                                             bool is_result) { 
+  indent(out) << "@implementation " << cocoa_prefix_ << tstruct->get_name() << endl << endl; 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  // exceptions need to call the designated initializer on NSException 
+  if (is_exception) { 
+    out << indent() << "- (instancetype) init" << endl; 
+    scope_up(out); 
+    out << indent() << "return [super initWithDomain: " << cocoa_prefix_ << capitalize(program_name_) << "ErrorDomain" << endl 
+        << indent() << "                        code: " << cocoa_prefix_ << capitalize(program_name_) << "Error" << tstruct->get_name() << endl 
+        << indent() << "                    userInfo: nil];" << endl; 
+    scope_down(out); 
+    out << endl; 
+  } else { 
+    // struct 
+ 
+    // default initializer 
+    // setup instance variables with default values 
+    indent(out) << "- (instancetype) init" << endl; 
+    scope_up(out); 
+    indent(out) << "self = [super init];" << endl; 
+    indent(out) << "if (self)"; 
+    scope_up(out); 
+    if (members.size() > 0) { 
+      for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+        t_type* t = get_true_type((*m_iter)->get_type()); 
+        if ((*m_iter)->get_value() != NULL) { 
+          print_const_value(out, 
+                            "self." + (*m_iter)->get_name(), 
+                            t, 
+                            (*m_iter)->get_value(), 
+                            false); 
+        } 
+      } 
+    } 
+    scope_down(out); 
+    indent(out) << "return self;" << endl; 
+    scope_down(out); 
+    out << endl; 
+  } 
+ 
+  // initializer with all fields as params 
+  if (!members.empty()) { 
+    generate_cocoa_struct_initializer_signature(out, tstruct); 
+    out << endl; 
+    scope_up(out); 
+    if (is_exception) { 
+      out << indent() << "self = [self init];" << endl; 
+    } else { 
+      out << indent() << "self = [super init];" << endl; 
+    } 
+ 
+    indent(out) << "if (self)"; 
+    scope_up(out); 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      out << indent() << "_" << (*m_iter)->get_name() << " = "; 
+      if (get_true_type((*m_iter)->get_type())->is_container()) { 
+        out << "[" << (*m_iter)->get_name() << " mutableCopy];" << endl; 
+      } else { 
+        out << (*m_iter)->get_name() << ";" << endl; 
+      } 
+      out << indent() << "_" << (*m_iter)->get_name() << "IsSet = YES;" << endl; 
+    } 
+    scope_down(out); 
+ 
+    out << indent() << "return self;" << endl; 
+    scope_down(out); 
+    out << endl; 
+  } 
+ 
+  // initWithCoder for NSCoding 
+  generate_cocoa_struct_init_with_coder_method(out, tstruct, is_exception); 
+  // encodeWithCoder for NSCoding 
+  generate_cocoa_struct_encode_with_coder_method(out, tstruct, is_exception); 
+  // hash and isEqual for NSObject 
+  generate_cocoa_struct_hash_method(out, tstruct); 
+  generate_cocoa_struct_is_equal_method(out, tstruct, is_exception); 
+  // copy for NSObject 
+  generate_cocoa_struct_copy_method(out, tstruct, is_exception); 
+ 
+  // the rest of the methods 
+  generate_cocoa_struct_field_accessor_implementations(out, tstruct, is_exception); 
+  generate_cocoa_struct_reader(out, tstruct); 
+  if (is_result) { 
+    generate_cocoa_struct_result_writer(out, tstruct); 
+  } else { 
+    generate_cocoa_struct_writer(out, tstruct); 
+  } 
+  generate_cocoa_struct_validator(out, tstruct); 
+  generate_cocoa_struct_description(out, tstruct); 
+ 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a function to read all the fields of the struct. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_reader(ostream& out, t_struct* tstruct) { 
+  out << "- (BOOL) read: (id <TProtocol>) inProtocol error: (NSError *__autoreleasing *)__thriftError" << endl; 
+  scope_up(out); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  // Declare stack tmp variables 
+  indent(out) << "NSString * fieldName;" << endl; 
+  indent(out) << "SInt32 fieldType;" << endl; 
+  indent(out) << "SInt32 fieldID;" << endl; 
+  out << endl; 
+ 
+  indent(out) << "if (![inProtocol readStructBeginReturningName: NULL error: __thriftError]) return NO;" << endl; 
+ 
+  // Loop over reading in fields 
+  indent(out) << "while (true)" << endl; 
+  scope_up(out); 
+ 
+  // Read beginning field marker 
+  indent(out) 
+      << "if (![inProtocol readFieldBeginReturningName: &fieldName type: &fieldType fieldID: &fieldID error: __thriftError]) return NO;" 
+      << endl; 
+ 
+  // Check for field STOP marker and break 
+  indent(out) << "if (fieldType == TTypeSTOP) { " << endl; 
+  indent_up(); 
+  indent(out) << "break;" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+ 
+  // Switch statement on the field we are reading 
+  indent(out) << "switch (fieldID)" << endl; 
+ 
+  scope_up(out); 
+ 
+  // Generate deserialization code for known cases 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl; 
+    indent_up(); 
+    indent(out) << "if (fieldType == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl; 
+    indent_up(); 
+ 
+    generate_deserialize_field(out, *f_iter, "fieldValue"); 
+    indent(out) << call_field_setter(*f_iter, "fieldValue") << endl; 
+ 
+    indent_down(); 
+    out << indent() << "} else { " << endl; 
+    if (log_unexpected_) { 
+      out << indent() << "  NSLog(@\"%s: field ID %i has unexpected type %i.  Skipping.\", " 
+                         "__PRETTY_FUNCTION__, (int)fieldID, (int)fieldType);" << endl; 
+    } 
+ 
+    out << indent() << "  if (![TProtocolUtil skipType: fieldType onProtocol: inProtocol error: __thriftError]) return NO;" << endl; 
+    out << indent() << "}" << endl << indent() << "break;" << endl; 
+    indent_down(); 
+  } 
+ 
+  // In the default case we skip the field 
+  out << indent() << "default:" << endl; 
+  if (log_unexpected_) { 
+    out << indent() << "  NSLog(@\"%s: unexpected field ID %i with type %i.  Skipping.\", " 
+                       "__PRETTY_FUNCTION__, (int)fieldID, (int)fieldType);" << endl; 
+  } 
+ 
+  out << indent() << "  if (![TProtocolUtil skipType: fieldType onProtocol: inProtocol error: __thriftError]) return NO;" << endl; 
+ 
+  out << indent() << "  break;" << endl; 
+ 
+  scope_down(out); 
+ 
+  // Read field end marker 
+  indent(out) << "if (![inProtocol readFieldEnd: __thriftError]) return NO;" << endl; 
+ 
+  scope_down(out); 
+ 
+  out << indent() << "if (![inProtocol readStructEnd: __thriftError]) return NO;" << endl; 
+ 
+  // performs various checks (e.g. check that all required fields are set) 
+  if (validate_required_) { 
+    out << indent() << "if (![self validate: __thriftError]) return NO;" << endl; 
+  } 
+ 
+  indent(out) << "return YES;" << endl; 
+ 
+  indent_down(); 
+  out << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a function to write all the fields of the struct 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_writer(ostream& out, t_struct* tstruct) { 
+  out << indent() << "- (BOOL) write: (id <TProtocol>) outProtocol error: (NSError *__autoreleasing *)__thriftError {" << endl; 
+  indent_up(); 
+ 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  out << indent() << "if (![outProtocol writeStructBeginWithName: @\"" << name << "\" error: __thriftError]) return NO;" << endl; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    out << indent() << "if (_" << (*f_iter)->get_name() << "IsSet) {" << endl; 
+    indent_up(); 
+    bool null_allowed = type_can_be_null((*f_iter)->get_type()); 
+    if (null_allowed) { 
+      out << indent() << "if (_" << (*f_iter)->get_name() << " != nil) {" << endl; 
+      indent_up(); 
+    } 
+ 
+    indent(out) << "if (![outProtocol writeFieldBeginWithName: @\"" << (*f_iter)->get_name() 
+                << "\" type: " << type_to_enum((*f_iter)->get_type()) 
+                << " fieldID: " << (*f_iter)->get_key() << " error: __thriftError]) return NO;" << endl; 
+ 
+    // Write field contents 
+    generate_serialize_field(out, *f_iter, "_" + (*f_iter)->get_name()); 
+ 
+    // Write field closer 
+    indent(out) << "if (![outProtocol writeFieldEnd: __thriftError]) return NO;" << endl; 
+ 
+    if (null_allowed) { 
+      scope_down(out); 
+    } 
+    scope_down(out); 
+  } 
+  // Write the struct map 
+  out << indent() << "if (![outProtocol writeFieldStop: __thriftError]) return NO;" << endl 
+      << indent() << "if (![outProtocol writeStructEnd: __thriftError]) return NO;" << endl; 
+ 
+  indent(out) << "return YES;" << endl; 
+ 
+  indent_down(); 
+  out << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a function to write all the fields of the struct, which 
+ * is a function result. These fields are only written if they are 
+ * set, and only one of them can be set at a time. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_result_writer(ostream& out, t_struct* tstruct) { 
+  out << indent() << "- (BOOL) write: (id <TProtocol>) outProtocol error: (NSError *__autoreleasing *)__thriftError {" << endl; 
+  indent_up(); 
+ 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  out << indent() << "if (![outProtocol writeStructBeginWithName: @\"" << name << "\" error: __thriftError]) return NO;" << endl; 
+ 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+      out << endl << indent() << "if "; 
+    } else { 
+      out << " else if "; 
+    } 
+ 
+    out << "(_" << (*f_iter)->get_name() << "IsSet) {" << endl; 
+    indent_up(); 
+ 
+    bool null_allowed = type_can_be_null((*f_iter)->get_type()); 
+    if (null_allowed) { 
+      out << indent() << "if (_" << (*f_iter)->get_name() << " != nil) {" << endl; 
+      indent_up(); 
+    } 
+ 
+    indent(out) << "if (![outProtocol writeFieldBeginWithName: @\"" << (*f_iter)->get_name() 
+                << "\" type: " << type_to_enum((*f_iter)->get_type()) 
+                << " fieldID: " << (*f_iter)->get_key() << " error: __thriftError]) return NO;" << endl; 
+ 
+    // Write field contents 
+    generate_serialize_field(out, *f_iter, "_" + (*f_iter)->get_name()); 
+ 
+    // Write field closer 
+    indent(out) << "if (![outProtocol writeFieldEnd: __thriftError]) return NO;" << endl; 
+ 
+    if (null_allowed) { 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } 
+ 
+    indent_down(); 
+    indent(out) << "}"; 
+  } 
+  // Write the struct map 
+  out << endl << indent() << "if (![outProtocol writeFieldStop: __thriftError]) return NO;" 
+      << endl << indent() << "if (![outProtocol writeStructEnd: __thriftError]) return NO;" 
+      << endl; 
+ 
+  indent(out) << "return YES;" << endl; 
+ 
+  indent_down(); 
+  out << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a function to perform various checks 
+ * (e.g. check that all required fields are set) 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_validator(ostream& out, t_struct* tstruct) { 
+  out << indent() << "- (BOOL) validate: (NSError *__autoreleasing *)__thriftError {" << endl; 
+  indent_up(); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  out << indent() << "// check for required fields" << endl; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_field* field = (*f_iter); 
+    if ((*f_iter)->get_req() == t_field::T_REQUIRED) { 
+      out << indent() << "if (!_" << field->get_name() << "IsSet) "; 
+      scope_up(out); 
+      indent(out) << "if (__thriftError) "; 
+      scope_up(out); 
+      out << indent() << "*__thriftError = [NSError errorWithDomain: TProtocolErrorDomain" << endl 
+          << indent() << "                                     code: TProtocolErrorUnknown" << endl 
+          << indent() << "                                 userInfo: @{TProtocolErrorExtendedErrorKey: @(TProtocolExtendedErrorMissingRequiredField)," << endl 
+          << indent() << "                                             TProtocolErrorFieldNameKey: @\"" << (*f_iter)->get_name() << "\"}];" << endl; 
+      scope_down(out); 
+      scope_down(out); 
+    } 
+  } 
+  indent(out) << "return YES;" << endl; 
+  indent_down(); 
+  out << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generate property accessor methods for all fields in the struct. 
+ * getter, setter, isset getter. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_field_accessor_implementations(ostream& out, 
+                                                                             t_struct* tstruct, 
+                                                                             bool is_exception) { 
+  (void)is_exception; 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_field* field = *f_iter; 
+    t_type* type = get_true_type(field->get_type()); 
+    std::string field_name = field->get_name(); 
+    std::string cap_name = field_name; 
+    cap_name[0] = toupper(cap_name[0]); 
+ 
+    // Simple setter 
+    indent(out) << "- (void) set" << cap_name << ": (" << type_name(type, false, true) << ") " << field_name 
+                << " {" << endl; 
+    indent_up(); 
+    indent(out) << "_" << field_name << " = " << field_name << ";" << endl; 
+    indent(out) << "_" << field_name << "IsSet = YES;" << endl; 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+ 
+    // Unsetter - do we need this? 
+    indent(out) << "- (void) unset" << cap_name << " {" << endl; 
+    indent_up(); 
+    if (type_can_be_null(type)) { 
+      indent(out) << "_" << field_name << " = nil;" << endl; 
+    } 
+    indent(out) << "_" << field_name << "IsSet = NO;" << endl; 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+  } 
+} 
+ 
+/** 
+ * Generates a description method for the given struct 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cocoa_generator::generate_cocoa_struct_description(ostream& out, t_struct* tstruct) { 
+ 
+  // Allow use of debugDescription so the app can add description via a cateogory/extension 
+  if (debug_descriptions_) { 
+    out << indent() << "- (NSString *) debugDescription {" << endl; 
+  } 
+  else { 
+    out << indent() << "- (NSString *) description {" << endl; 
+  } 
+  indent_up(); 
+ 
+  out << indent() << "NSMutableString * ms = [NSMutableString stringWithString: @\"" 
+      << cocoa_prefix_ << tstruct->get_name() << "(\"];" << endl; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+      indent(out) << "[ms appendString: @\"" << (*f_iter)->get_name() << ":\"];" << endl; 
+    } else { 
+      indent(out) << "[ms appendString: @\"," << (*f_iter)->get_name() << ":\"];" << endl; 
+    } 
+    t_type* ttype = (*f_iter)->get_type(); 
+    indent(out) << "[ms appendFormat: @\"" << format_string_for_type(ttype) << "\", " 
+                << format_cast_for_type(ttype) << "_" << (*f_iter)->get_name() << "];" << endl; 
+  } 
+  out << indent() << "[ms appendString: @\")\"];" << endl << indent() 
+      << "return [NSString stringWithString: ms];" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a thrift service.  In Objective-C this consists of a 
+ * protocol definition, a client interface and a client implementation. 
+ * 
+ * @param tservice The service definition 
+ */ 
+void t_cocoa_generator::generate_service(t_service* tservice) { 
+  generate_cocoa_service_protocol(f_header_, tservice); 
+  generate_cocoa_service_client_interface(f_header_, tservice); 
+  generate_cocoa_service_server_interface(f_header_, tservice); 
+  generate_cocoa_service_helpers(tservice); 
+  generate_cocoa_service_client_implementation(f_impl_, tservice); 
+  generate_cocoa_service_server_implementation(f_impl_, tservice); 
+  if (async_clients_) { 
+    generate_cocoa_service_async_protocol(f_header_, tservice); 
+    generate_cocoa_service_client_async_interface(f_header_, tservice); 
+    generate_cocoa_service_client_async_implementation(f_impl_, tservice); 
+  } 
+} 
+ 
+/** 
+ * Generates structs for all the service return types 
+ * 
+ * @param tservice The service 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_helpers(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+ 
+    t_struct* ts = (*f_iter)->get_arglist(); 
+ 
+    string qname = function_args_helper_struct_type(tservice, *f_iter); 
+ 
+    t_struct qname_ts = t_struct(ts->get_program(), qname); 
+ 
+    const vector<t_field*>& members = ts->get_members(); 
+    vector<t_field*>::const_iterator m_iter; 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      qname_ts.append(*m_iter); 
+    } 
+ 
+    generate_cocoa_struct_interface(f_impl_, &qname_ts, false); 
+    generate_cocoa_struct_implementation(f_impl_, &qname_ts, false, false); 
+    generate_function_helpers(tservice, *f_iter); 
+  } 
+} 
+ 
+string t_cocoa_generator::function_result_helper_struct_type(t_service *tservice, t_function* tfunction) { 
+  if (tfunction->is_oneway()) { 
+    return tservice->get_name() + "_" + tfunction->get_name(); 
+  } else { 
+    return tservice->get_name() + "_" + tfunction->get_name() + "_result"; 
+  } 
+} 
+ 
+string t_cocoa_generator::function_args_helper_struct_type(t_service *tservice, t_function* tfunction) { 
+  return tservice->get_name() + "_" + tfunction->get_name() + "_args"; 
+} 
+ 
+/** 
+ * Generates a struct and helpers for a function. 
+ * 
+ * @param tfunction The function 
+ */ 
+void t_cocoa_generator::generate_function_helpers(t_service *tservice, t_function* tfunction) { 
+  if (tfunction->is_oneway()) { 
+    return; 
+  } 
+ 
+  // create a result struct with a success field of the return type, 
+  // and a field for each type of exception thrown 
+  t_struct result(program_, function_result_helper_struct_type(tservice, tfunction)); 
+  t_field success(tfunction->get_returntype(), "success", 0); 
+  if (!tfunction->get_returntype()->is_void()) { 
+    result.append(&success); 
+  } 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const vector<t_field*>& fields = xs->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    result.append(*f_iter); 
+  } 
+ 
+  // generate the result struct 
+  generate_cocoa_struct_interface(f_impl_, &result, false); 
+  generate_cocoa_struct_implementation(f_impl_, &result, false, true); 
+} 
+ 
+/** 
+ * Generates a service protocol definition. 
+ * 
+ * @param tservice The service to generate a protocol definition for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_protocol(ostream& out, t_service* tservice) { 
+  out << "@protocol " << cocoa_prefix_ << tservice->get_name() << " <NSObject>" << endl; 
+ 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    out << "- " << function_signature(*f_iter, true) << ";" 
+        << "  // throws "; 
+    t_struct* xs = (*f_iter)->get_xceptions(); 
+    const std::vector<t_field*>& xceptions = xs->get_members(); 
+    vector<t_field*>::const_iterator x_iter; 
+    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+      out << type_name((*x_iter)->get_type()) + ", "; 
+    } 
+    out << "TException" << endl; 
+  } 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generates an asynchronous service protocol definition. 
+ * 
+ * @param tservice The service to generate a protocol definition for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_async_protocol(ostream& out, t_service* tservice) { 
+  out << "@protocol " << cocoa_prefix_ << tservice->get_name() << "Async" 
+      << " <NSObject>" << endl; 
+ 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    out << "- " << async_function_signature(*f_iter, false) << ";" << endl; 
+    if (promise_kit_) { 
+      out << "- " << promise_function_signature(*f_iter) << ";" << endl; 
+    } 
+  } 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a service client interface definition. 
+ * 
+ * @param tservice The service to generate a client interface definition for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_client_interface(ostream& out, 
+                                                                t_service* tservice) { 
+  out << "@interface " << cocoa_prefix_ << tservice->get_name() << "Client : TBaseClient <" 
+      << cocoa_prefix_ << tservice->get_name() << "> " << endl; 
+ 
+  out << "- (id) initWithProtocol: (id <TProtocol>) protocol;" << endl; 
+  out << "- (id) initWithInProtocol: (id <TProtocol>) inProtocol outProtocol: (id <TProtocol>) " 
+         "outProtocol;" << endl; 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a service client interface definition. 
+ * 
+ * @param tservice The service to generate a client interface definition for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_client_async_interface(ostream& out, 
+                                                                      t_service* tservice) { 
+  out << "@interface " << cocoa_prefix_ << tservice->get_name() << "ClientAsync : TBaseClient <" 
+      << cocoa_prefix_ << tservice->get_name() << "Async> " << endl 
+      << endl; 
+ 
+  out << "- (id) initWithProtocolFactory: (id <TProtocolFactory>) protocolFactory " 
+      << "transportFactory: (id <TAsyncTransportFactory>) transportFactory;" << endl; 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a service server interface definition. In other words, the TProcess implementation for 
+ *the 
+ * service definition. 
+ * 
+ * @param tservice The service to generate a client interface definition for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_server_interface(ostream& out, 
+                                                                t_service* tservice) { 
+  out << "@interface " << cocoa_prefix_ << tservice->get_name() 
+      << "Processor : NSObject <TProcessor> " << endl; 
+ 
+  out << "- (id) initWith" << tservice->get_name() << ": (id <" << cocoa_prefix_ 
+      << tservice->get_name() << ">) service;" << endl; 
+  out << "- (id<" << cocoa_prefix_ << tservice->get_name() << ">) service;" << endl; 
+ 
+  out << "@end" << endl << endl; 
+} 
+ 
+void t_cocoa_generator::generate_cocoa_service_client_send_function_implementation( 
+    ostream& out, 
+    t_service *tservice, 
+    t_function* tfunction, 
+    bool needs_protocol) { 
+  string funname = tfunction->get_name(); 
+ 
+  t_function send_function(g_type_bool, 
+                           string("send_") + tfunction->get_name(), 
+                           tfunction->get_arglist()); 
+ 
+  string argsname = function_args_helper_struct_type(tservice, tfunction); 
+ 
+  // Open function 
+  indent(out) << "- (BOOL) send_" << tfunction->get_name() << argument_list(tfunction->get_arglist(), needs_protocol ? "outProtocol" : "", true) << endl; 
+  scope_up(out); 
+ 
+  // Serialize the request 
+  out << indent() << "if (![outProtocol writeMessageBeginWithName: @\"" << funname << "\"" 
+      << (tfunction->is_oneway() ? " type: TMessageTypeONEWAY" : " type: TMessageTypeCALL") 
+      << " sequenceID: 0 error: __thriftError]) return NO;" << endl; 
+ 
+  out << indent() << "if (![outProtocol writeStructBeginWithName: @\"" << argsname 
+                  << "\" error: __thriftError]) return NO;" << endl; 
+ 
+  // write out function parameters 
+  t_struct* arg_struct = tfunction->get_arglist(); 
+  const vector<t_field*>& fields = arg_struct->get_members(); 
+  vector<t_field*>::const_iterator fld_iter; 
+  for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+    string fieldName = (*fld_iter)->get_name(); 
+    if (type_can_be_null((*fld_iter)->get_type())) { 
+      out << indent() << "if (" << fieldName << " != nil)"; 
+      scope_up(out); 
+    } 
+    out << indent() << "if (![outProtocol writeFieldBeginWithName: @\"" << fieldName 
+        << "\"" 
+           " type: " << type_to_enum((*fld_iter)->get_type()) 
+        << " fieldID: " << (*fld_iter)->get_key() << " error: __thriftError]) return NO;" << endl; 
+ 
+    generate_serialize_field(out, *fld_iter, fieldName); 
+ 
+    out << indent() << "if (![outProtocol writeFieldEnd: __thriftError]) return NO;" << endl; 
+ 
+    if (type_can_be_null((*fld_iter)->get_type())) { 
+      indent_down(); 
+      out << indent() << "}" << endl; 
+    } 
+  } 
+ 
+  out << indent() << "if (![outProtocol writeFieldStop: __thriftError]) return NO;" << endl; 
+  out << indent() << "if (![outProtocol writeStructEnd: __thriftError]) return NO;" << endl; 
+  out << indent() << "if (![outProtocol writeMessageEnd: __thriftError]) return NO;" << endl; 
+  out << indent() << "return YES;" << endl; 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+void t_cocoa_generator::generate_cocoa_service_client_recv_function_implementation( 
+    ostream& out, 
+    t_service* tservice, 
+    t_function* tfunction, 
+    bool needs_protocol) { 
+ 
+ 
+  // Open function 
+  indent(out) << "- (BOOL) recv_" << tfunction->get_name(); 
+  if (!tfunction->get_returntype()->is_void()) { 
+    out << ": (" << type_name(tfunction->get_returntype(), false, true) << " *) result "; 
+    if (needs_protocol) { 
+      out << "protocol"; 
+    } else { 
+      out << "error"; 
+    } 
+  } 
+  if (needs_protocol) { 
+    out << ": (id<TProtocol>) inProtocol error"; 
+  } 
+  out << ": (NSError *__autoreleasing *)__thriftError" << endl; 
+  scope_up(out); 
+ 
+  // TODO(mcslee): Message validation here, was the seqid etc ok? 
+ 
+  // check for an exception 
+  out << indent() << "NSError *incomingException = [self checkIncomingMessageException: inProtocol];" << endl 
+      << indent() << "if (incomingException)"; 
+  scope_up(out); 
+  out << indent() << "if (__thriftError)"; 
+  scope_up(out); 
+  out << indent() << "*__thriftError = incomingException;" << endl; 
+  scope_down(out); 
+  out << indent() << "return NO;" << endl; 
+  scope_down(out); 
+ 
+  // FIXME - could optimize here to reduce creation of temporary objects. 
+  string resultname = function_result_helper_struct_type(tservice, tfunction); 
+  out << indent() << cocoa_prefix_ << resultname << " * resulter = [" << cocoa_prefix_ << resultname << " new];" << endl; 
+  indent(out) << "if (![resulter read: inProtocol error: __thriftError]) return NO;" << endl; 
+  indent(out) << "if (![inProtocol readMessageEnd: __thriftError]) return NO;" << endl; 
+ 
+  // Careful, only return _result if not a void function 
+  if (!tfunction->get_returntype()->is_void()) { 
+    out << indent() << "if (resulter.successIsSet)"; 
+    scope_up(out); 
+    out << indent() << "*result = resulter.success;" << endl; 
+    out << indent() << "return YES;" << endl; 
+    scope_down(out); 
+  } 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const std::vector<t_field*>& xceptions = xs->get_members(); 
+  vector<t_field*>::const_iterator x_iter; 
+  for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+    out << indent() << "if (resulter." << (*x_iter)->get_name() << "IsSet)"; 
+    scope_up(out); 
+    out << indent() << "if (__thriftError)"; 
+    scope_up(out); 
+    out << indent() << "*__thriftError = [resulter " << (*x_iter)->get_name() << "];" << endl; 
+    scope_down(out); 
+    out << indent() << "return NO;" << endl; 
+    scope_down(out); 
+  } 
+ 
+  // If you get here it's an exception, unless a void function 
+  if (tfunction->get_returntype()->is_void()) { 
+    indent(out) << "return YES;" << endl; 
+  } else { 
+    out << indent() << "if (__thriftError)"; 
+    scope_up(out); 
+    out << indent() << "*__thriftError = [NSError errorWithDomain: TApplicationErrorDomain" << endl 
+        << indent() << "                                     code: TApplicationErrorMissingResult" << endl 
+        << indent() << "                                 userInfo: @{TApplicationErrorMethodKey: @\"" 
+        << tfunction->get_name() << "\"}];" << endl; 
+    scope_down(out); 
+    out << indent() << "return NO;" << endl; 
+  } 
+ 
+  // Close function 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+/** 
+ * Generates an invocation of a given 'send_' function. 
+ * 
+ * @param tfunction The service to generate an implementation for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_client_send_function_invocation( 
+                                                                               ostream& out, 
+                                                                               t_function* tfunction) { 
+ 
+  t_struct* arg_struct = tfunction->get_arglist(); 
+  const vector<t_field*>& fields = arg_struct->get_members(); 
+  vector<t_field*>::const_iterator fld_iter; 
+  out << indent() << "if (![self send_" << tfunction->get_name(); 
+  bool first = true; 
+  for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+    string fieldName = (*fld_iter)->get_name(); 
+    out << " "; 
+    if (first) { 
+      first = false; 
+      out << ": " << fieldName; 
+    } else { 
+      out << fieldName << ": " << fieldName; 
+    } 
+  } 
+  if (!fields.empty()) { 
+    out << " error"; 
+  } 
+  out << ": __thriftError]) " << invalid_return_statement(tfunction) << endl; 
+} 
+ 
+/** 
+ * Generates an invocation of a given 'send_' function. 
+ * 
+ * @param tfunction The service to generate an implementation for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_client_send_async_function_invocation( 
+                                                                                     ostream& out, 
+                                                                                     t_function* tfunction, 
+                                                                                     string failureBlockName) { 
+ 
+  t_struct* arg_struct = tfunction->get_arglist(); 
+  const vector<t_field*>& fields = arg_struct->get_members(); 
+  vector<t_field*>::const_iterator fld_iter; 
+  out << indent() << "if (![self send_" << tfunction->get_name(); 
+  bool first = true; 
+  for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+    string fieldName = (*fld_iter)->get_name(); 
+    out << " "; 
+    if (first) { 
+      first = false; 
+      out << ": " << fieldName; 
+    } else { 
+      out << fieldName << ": " << fieldName; 
+    } 
+  } 
+  if (!fields.empty()) { 
+    out << " protocol"; 
+  } 
+  out << ": protocol error: &thriftError]) "; 
+  scope_up(out); 
+  out << indent() << failureBlockName << "(thriftError);" << endl 
+      << indent() << "return;" << endl; 
+  scope_down(out); 
+} 
+ 
+/** 
+ * Generates a service client implementation. 
+ * 
+ * @param tservice The service to generate an implementation for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_client_implementation(ostream& out, 
+                                                                     t_service* tservice) { 
+ 
+  string name = cocoa_prefix_ + tservice->get_name() + "Client"; 
+ 
+  out << "@interface " << name << " () "; 
+  scope_up(out); 
+  out << endl; 
+  out << indent() << "id<TProtocol> inProtocol;" << endl; 
+  out << indent() << "id<TProtocol> outProtocol;" << endl; 
+  out << endl; 
+  scope_down(out); 
+  out << endl; 
+  out << "@end" << endl << endl; 
+ 
+  out << "@implementation " << name << endl; 
+ 
+  // initializers 
+  out << "- (id) initWithProtocol: (id <TProtocol>) protocol" << endl; 
+  scope_up(out); 
+  out << indent() << "return [self initWithInProtocol: protocol outProtocol: protocol];" << endl; 
+  scope_down(out); 
+  out << endl; 
+ 
+  out << "- (id) initWithInProtocol: (id <TProtocol>) anInProtocol outProtocol: (id <TProtocol>) " 
+         "anOutProtocol" << endl; 
+  scope_up(out); 
+  out << indent() << "self = [super init];" << endl; 
+  out << indent() << "if (self) "; 
+  scope_up(out); 
+  out << indent() << "inProtocol = anInProtocol;" << endl; 
+  out << indent() << "outProtocol = anOutProtocol;" << endl; 
+  scope_down(out); 
+  out << indent() << "return self;" << endl; 
+  scope_down(out); 
+  out << endl; 
+ 
+  // generate client method implementations 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+ 
+    generate_cocoa_service_client_send_function_implementation(out, tservice, *f_iter, false); 
+ 
+    if (!(*f_iter)->is_oneway()) { 
+      generate_cocoa_service_client_recv_function_implementation(out, tservice, *f_iter, false); 
+    } 
+ 
+    // Open function 
+    indent(out) << "- " << function_signature(*f_iter, true) << endl; 
+    scope_up(out); 
+    generate_cocoa_service_client_send_function_invocation(out, *f_iter); 
+ 
+    out << indent() << "if (![[outProtocol transport] flush: __thriftError]) " << invalid_return_statement(*f_iter) << endl; 
+    if (!(*f_iter)->is_oneway()) { 
+      if ((*f_iter)->get_returntype()->is_void()) { 
+        out << indent() << "if (![self recv_" << (*f_iter)->get_name() << ": __thriftError]) return NO;" << endl; 
+        out << indent() << "return YES;" << endl; 
+      } else { 
+        out << indent() << type_name((*f_iter)->get_returntype(), false, true) << " __result;" << endl 
+            << indent() << "if (![self recv_" << (*f_iter)->get_name() << ": &__result error: __thriftError]) " 
+            << invalid_return_statement(*f_iter) << endl; 
+        if (type_can_be_null((*f_iter)->get_returntype())) { 
+          out << indent() << "return __result;" << endl; 
+        } else { 
+          out << indent() << "return @(__result);" << endl; 
+        } 
+      } 
+    } 
+    else { 
+      out << indent() << "return YES;" << endl; 
+    } 
+    scope_down(out); 
+    out << endl; 
+  } 
+ 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a service client implementation for its asynchronous interface. 
+ * 
+ * @param tservice The service to generate an implementation for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_client_async_implementation(ostream& out, 
+                                                                           t_service* tservice) { 
+ 
+  string name = cocoa_prefix_ + tservice->get_name() + "ClientAsync"; 
+ 
+  out << "@interface " << name << " () "; 
+  scope_up(out); 
+  out << endl; 
+  out << indent() << "id<TProtocolFactory> protocolFactory;" << endl; 
+  out << indent() << "id<TAsyncTransportFactory> transportFactory;" << endl; 
+  out << endl; 
+  scope_down(out); 
+  out << endl; 
+  out << "@end" << endl << endl; 
+ 
+ 
+  out << "@implementation " << name << endl 
+      << endl << "- (id) initWithProtocolFactory: (id <TProtocolFactory>) aProtocolFactory " 
+                 "transportFactory: (id <TAsyncTransportFactory>) aTransportFactory;" << endl; 
+ 
+  scope_up(out); 
+  out << indent() << "self = [super init];" << endl; 
+  out << indent() << "if (self) {" << endl; 
+  out << indent() << "  protocolFactory = aProtocolFactory;" << endl; 
+  out << indent() << "  transportFactory = aTransportFactory;" << endl; 
+  out << indent() << "}" << endl; 
+  out << indent() << "return self;" << endl; 
+  scope_down(out); 
+  out << endl; 
+ 
+  // generate client method implementations 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+ 
+    generate_cocoa_service_client_send_function_implementation(out, tservice, *f_iter, true); 
+ 
+    if (!(*f_iter)->is_oneway()) { 
+      generate_cocoa_service_client_recv_function_implementation(out, tservice, *f_iter, true); 
+    } 
+ 
+    // Open function 
+    indent(out) << "- " << async_function_signature(*f_iter, false) << endl; 
+    scope_up(out); 
+ 
+    out << indent() << "NSError *thriftError;" << endl 
+        << indent() << "id<TAsyncTransport> transport = [transportFactory newTransport];" << endl 
+        << indent() << "id<TProtocol> protocol = [protocolFactory newProtocolOnTransport:transport];" << endl 
+        << endl; 
+ 
+    generate_cocoa_service_client_send_async_function_invocation(out, *f_iter, "failureBlock"); 
+ 
+    out << indent() << "[transport flushWithCompletion:^{" << endl; 
+    indent_up(); 
+ 
+    if (!(*f_iter)->is_oneway()) { 
+      out << indent() << "NSError *thriftError;" << endl; 
+ 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        out << indent() << type_name((*f_iter)->get_returntype()) << " result;" << endl; 
+      } 
+      out << indent() << "if (![self recv_" << (*f_iter)->get_name(); 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        out << ": &result protocol"; 
+      } 
+      out << ": protocol error: &thriftError]) "; 
+      scope_up(out); 
+      out << indent() << "failureBlock(thriftError);" << endl 
+          << indent() << "return;" << endl; 
+      scope_down(out); 
+    } 
+ 
+    out << indent() << "responseBlock("; 
+    if (!(*f_iter)->is_oneway() && !(*f_iter)->get_returntype()->is_void()) { 
+      out << "result"; 
+    } 
+    out << ");" << endl; 
+ 
+    indent_down(); 
+ 
+    out << indent() << "} failure:failureBlock];" << endl; 
+ 
+    scope_down(out); 
+ 
+    out << endl; 
+ 
+    // Promise function 
+    if (promise_kit_) { 
+ 
+      indent(out) << "- " << promise_function_signature(*f_iter) << endl; 
+      scope_up(out); 
+ 
+      out << indent() << "return [AnyPromise promiseWithResolverBlock:^(PMKResolver resolver) {" << endl; 
+      indent_up(); 
+ 
+      out << indent() << "NSError *thriftError;" << endl 
+          << indent() << "id<TAsyncTransport> transport = [transportFactory newTransport];" << endl 
+          << indent() << "id<TProtocol> protocol = [protocolFactory newProtocolOnTransport:transport];" << endl 
+          << endl; 
+ 
+      generate_cocoa_service_client_send_async_function_invocation(out, *f_iter, "resolver"); 
+ 
+      out << indent() << "[transport flushWithCompletion:^{" << endl; 
+      indent_up(); 
+ 
+      if (!(*f_iter)->is_oneway()) { 
+        out << indent() << "NSError *thriftError;" << endl; 
+ 
+        if (!(*f_iter)->get_returntype()->is_void()) { 
+          out << indent() << type_name((*f_iter)->get_returntype()) << " result;" << endl; 
+        } 
+        out << indent() << "if (![self recv_" << (*f_iter)->get_name(); 
+        if (!(*f_iter)->get_returntype()->is_void()) { 
+          out << ": &result protocol"; 
+        } 
+        out << ": protocol error: &thriftError]) "; 
+        scope_up(out); 
+        out << indent() << "resolver(thriftError);" << endl 
+            << indent() << "return;" << endl; 
+        scope_down(out); 
+      } 
+ 
+      out << indent() << "resolver("; 
+      if ((*f_iter)->is_oneway() || (*f_iter)->get_returntype()->is_void()) { 
+        out << "@YES"; 
+      } else if (type_can_be_null((*f_iter)->get_returntype())) { 
+        out << "result"; 
+      } else { 
+        out << "@(result)"; 
+      } 
+      out << ");" << endl; 
+ 
+      indent_down(); 
+ 
+      out << indent() << "} failure:^(NSError *error) {" << endl; 
+      indent_up(); 
+      out << indent() << "resolver(error);" << endl; 
+      indent_down(); 
+      out << indent() << "}];" << endl; 
+ 
+      indent_down(); 
+      out << indent() << "}];" << endl; 
+ 
+      scope_down(out); 
+ 
+      out << endl; 
+ 
+    } 
+ 
+  } 
+ 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a service server implementation.  In other words the actual TProcessor implementation 
+ * for the service. 
+ * 
+ * @param tservice The service to generate an implementation for 
+ */ 
+void t_cocoa_generator::generate_cocoa_service_server_implementation(ostream& out, 
+                                                                     t_service* tservice) { 
+ 
+  string name = cocoa_prefix_ + tservice->get_name() + "Processor"; 
+ 
+  out << "@interface " << name << " () "; 
+ 
+  scope_up(out); 
+  out << indent() << "id <" << cocoa_prefix_ << tservice->get_name() << "> service;" << endl; 
+  out << indent() << "NSDictionary * methodMap;" << endl; 
+  scope_down(out); 
+ 
+  out << "@end" << endl << endl; 
+ 
+  out << "@implementation " << name << endl; 
+ 
+  // initializer 
+  out << endl; 
+  out << "- (id) initWith" << tservice->get_name() << ": (id <" << cocoa_prefix_ << tservice->get_name() << ">) aService" << endl; 
+  scope_up(out); 
+  out << indent() << "self = [super init];" << endl; 
+  out << indent() << "if (self) "; 
+  scope_up(out); 
+  out << indent() << "service = aService;" << endl; 
+  out << indent() << "methodMap = [NSMutableDictionary dictionary];" << endl; 
+ 
+  // generate method map for routing incoming calls 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    string funname = (*f_iter)->get_name(); 
+    scope_up(out); 
+    out << indent() << "SEL s = @selector(process_" << funname << "_withSequenceID:inProtocol:outProtocol:error:);" << endl; 
+    out << indent() << "NSMethodSignature * sig = [self methodSignatureForSelector: s];" << endl; 
+    out << indent() << "NSInvocation * invocation = [NSInvocation invocationWithMethodSignature: sig];" << endl; 
+    out << indent() << "[invocation setSelector: s];" << endl; 
+    out << indent() << "[invocation retainArguments];" << endl; 
+    out << indent() << "[methodMap setValue: invocation forKey: @\"" << funname << "\"];" << endl; 
+    scope_down(out); 
+  } 
+  scope_down(out); 
+  out << indent() << "return self;" << endl; 
+  scope_down(out); 
+ 
+  // implementation of the 'service' method which returns the service associated with this 
+  // processor 
+  out << endl; 
+  out << indent() << "- (id<" << cocoa_prefix_ << tservice->get_name() << ">) service" << endl; 
+  out << indent() << "{" << endl; 
+  out << indent() << "  return service;" << endl; 
+  out << indent() << "}" << endl; 
+ 
+  // implementation of the TProcess method, which dispatches the incoming call using the method map 
+  out << endl; 
+  out << indent() << "- (BOOL) processOnInputProtocol: (id <TProtocol>) inProtocol" << endl; 
+  out << indent() << "                 outputProtocol: (id <TProtocol>) outProtocol" << endl; 
+  out << indent() << "                          error: (NSError *__autoreleasing *)__thriftError" << endl; 
+  out << indent() << "{" << endl; 
+  out << indent() << "  NSString * messageName;" << endl; 
+  out << indent() << "  SInt32 messageType;" << endl; 
+  out << indent() << "  SInt32 seqID;" << endl; 
+  out << indent() << "  if (![inProtocol readMessageBeginReturningName: &messageName" << endl; 
+  out << indent() << "                                       type: &messageType" << endl; 
+  out << indent() << "                                 sequenceID: &seqID" << endl; 
+  out << indent() << "                                      error: __thriftError]) return NO;" << endl; 
+  out << indent() << "  NSInvocation * invocation = [methodMap valueForKey: messageName];" << endl; 
+  out << indent() << "  if (invocation == nil) {" << endl; 
+  out << indent() << "    if (![TProtocolUtil skipType: TTypeSTRUCT onProtocol: inProtocol error: __thriftError]) return NO;" << endl; 
+  out << indent() << "    if (![inProtocol readMessageEnd: __thriftError]) return NO;" << endl; 
+  out << indent() << "    NSError * x = [NSError errorWithDomain: TApplicationErrorDomain" << endl; 
+  out << indent() << "                                      code: TApplicationErrorUnknownMethod" << endl; 
+  out << indent() << "                                  userInfo: @{TApplicationErrorMethodKey: messageName}];" << endl; 
+  out << indent() << "    if (![outProtocol writeMessageBeginWithName: messageName" << endl; 
+  out << indent() << "                                           type: TMessageTypeEXCEPTION" << endl; 
+  out << indent() << "                                     sequenceID: seqID" << endl; 
+  out << indent() << "                                          error: __thriftError]) return NO;" << endl; 
+  out << indent() << "    if (![x write: outProtocol error: __thriftError]) return NO;" << endl; 
+  out << indent() << "    if (![outProtocol writeMessageEnd: __thriftError]) return NO;" << endl; 
+  out << indent() << "    if (![[outProtocol transport] flush: __thriftError]) return NO;" << endl; 
+  out << indent() << "    return YES;" << endl; 
+  out << indent() << "  }" << endl; 
+  out << indent() << "  // NSInvocation does not conform to NSCopying protocol" << endl; 
+  out << indent() << "  NSInvocation * i = [NSInvocation invocationWithMethodSignature: " 
+                     "[invocation methodSignature]];" << endl; 
+  out << indent() << "  [i setSelector: [invocation selector]];" << endl; 
+  out << indent() << "  [i setArgument: &seqID atIndex: 2];" << endl; 
+  out << indent() << "  [i setArgument: &inProtocol atIndex: 3];" << endl; 
+  out << indent() << "  [i setArgument: &outProtocol atIndex: 4];" << endl; 
+  out << indent() << "  [i setArgument: &__thriftError atIndex: 5];" << endl; 
+  out << indent() << "  [i setTarget: self];" << endl; 
+  out << indent() << "  [i invoke];" << endl; 
+  out << indent() << "  return YES;" << endl; 
+  out << indent() << "}" << endl; 
+ 
+  // generate a process_XXXX method for each service function, which reads args, calls the service, 
+  // and writes results 
+  functions = tservice->get_functions(); 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    out << endl; 
+    string funname = (*f_iter)->get_name(); 
+    out << indent() << "- (BOOL) process_" << funname 
+        << "_withSequenceID: (SInt32) seqID inProtocol: (id<TProtocol>) inProtocol outProtocol: " 
+           "(id<TProtocol>) outProtocol error:(NSError *__autoreleasing *)__thriftError" << endl; 
+    scope_up(out); 
+    string argstype = cocoa_prefix_ + function_args_helper_struct_type(tservice, *f_iter); 
+    out << indent() << argstype << " * args = [" << argstype << " new];" << endl; 
+    out << indent() << "if (![args read: inProtocol error: __thriftError]) return NO;" << endl; 
+    out << indent() << "if (![inProtocol readMessageEnd: __thriftError]) return NO;" << endl; 
+ 
+    // prepare the result if not oneway 
+    if (!(*f_iter)->is_oneway()) { 
+      string resulttype = cocoa_prefix_ + function_result_helper_struct_type(tservice, *f_iter); 
+      out << indent() << resulttype << " * result = [" << resulttype << " new];" << endl; 
+    } 
+ 
+    // make the call to the actual service object 
+    out << indent(); 
+    if ((*f_iter)->get_returntype()->is_void()) { 
+      out << "BOOL"; 
+    } else if (type_can_be_null((*f_iter)->get_returntype())) { 
+      out << type_name((*f_iter)->get_returntype(), false, true); 
+    } else { 
+      out << "NSNumber *"; 
+    } 
+    out << " serviceResult = "; 
+    if ((*f_iter)->get_returntype()->get_true_type()->is_container()) { 
+      out << "(" << type_name((*f_iter)->get_returntype(), false, true) << ")"; 
+    } 
+    out << "[service " << funname; 
+    // supplying arguments 
+    t_struct* arg_struct = (*f_iter)->get_arglist(); 
+    const vector<t_field*>& fields = arg_struct->get_members(); 
+    vector<t_field*>::const_iterator fld_iter; 
+    bool first = true; 
+    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+      string fieldName = (*fld_iter)->get_name(); 
+      if (first) { 
+        first = false; 
+        out << ": [args " << fieldName << "]"; 
+      } else { 
+        out << " " << fieldName << ": [args " << fieldName << "]"; 
+      } 
+    } 
+    if (!fields.empty()) { 
+      out << " error"; 
+    } 
+    out << ": __thriftError];" << endl; 
+    out << indent() << "if (!serviceResult) return NO;" << endl; 
+    if (!(*f_iter)->get_returntype()->is_void()) { 
+      out << indent() << "[result setSuccess: " << unbox((*f_iter)->get_returntype(), "serviceResult") << "];" << endl; 
+    } 
+ 
+    // write out the result if not oneway 
+    if (!(*f_iter)->is_oneway()) { 
+      out << indent() << "if (![outProtocol writeMessageBeginWithName: @\"" << funname << "\"" << endl; 
+      out << indent() << "                                       type: TMessageTypeREPLY" << endl; 
+      out << indent() << "                                 sequenceID: seqID" << endl; 
+      out << indent() << "                                      error: __thriftError]) return NO;" << endl; 
+      out << indent() << "if (![result write: outProtocol error: __thriftError]) return NO;" << endl; 
+      out << indent() << "if (![outProtocol writeMessageEnd: __thriftError]) return NO;" << endl; 
+      out << indent() << "if (![[outProtocol transport] flush: __thriftError]) return NO;" << endl; 
+    } 
+    out << indent() << "return YES;" << endl; 
+ 
+    scope_down(out); 
+  } 
+ 
+  out << "@end" << endl << endl; 
+} 
+ 
+/** 
+ * Deserializes a field of any type. 
+ * 
+ * @param tfield The field 
+ * @param fieldName The variable name for this field 
+ */ 
+void t_cocoa_generator::generate_deserialize_field(ostream& out, 
+                                                   t_field* tfield, 
+                                                   string fieldName) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+ 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + tfield->get_name(); 
+  } 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_deserialize_struct(out, (t_struct*)type, fieldName); 
+  } else if (type->is_container()) { 
+    generate_deserialize_container(out, type, fieldName); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+    indent(out) << type_name(type) << " " << fieldName << ";" << endl; 
+    indent(out) << "if (![inProtocol "; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + tfield->get_name(); 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "readBinary:&" << fieldName << " error: __thriftError]"; 
+        } else { 
+          out << "readString:&" << fieldName << " error: __thriftError]"; 
+        } 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "readBool:&" << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "readByte:(UInt8 *)&" << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "readI16:&" << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "readI32:&" << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "readI64:&" << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "readDouble:&" << fieldName << " error: __thriftError]"; 
+        break; 
+      default: 
+        throw "compiler error: no Objective-C name for base type " 
+            + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      out << "readI32:&" << fieldName << " error: __thriftError]"; 
+    } 
+    out << ") return NO;" << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n", 
+           tfield->get_name().c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+/** 
+ * Generates an unserializer for a struct, allocates the struct and invokes read: 
+ */ 
+void t_cocoa_generator::generate_deserialize_struct(ostream& out, 
+                                                    t_struct* tstruct, 
+                                                    string fieldName) { 
+  indent(out) << type_name(tstruct) << fieldName << " = [[" << type_name(tstruct, true) 
+              << " alloc] init];" << endl; 
+  indent(out) << "if (![" << fieldName << " read: inProtocol error: __thriftError]) return NO;" << endl; 
+} 
+ 
+/** 
+ * Deserializes a container by reading its size and then iterating 
+ */ 
+void t_cocoa_generator::generate_deserialize_container(ostream& out, 
+                                                       t_type* ttype, 
+                                                       string fieldName) { 
+  string size = tmp("_size"); 
+  indent(out) << "SInt32 " << size << ";" << endl; 
+ 
+  // Declare variables, read header 
+  if (ttype->is_map()) { 
+    indent(out) << "if (![inProtocol readMapBeginReturningKeyType: NULL valueType: NULL size: &" << size << " error: __thriftError]) return NO;" << endl; 
+    indent(out) << "NSMutableDictionary * " << fieldName 
+                << " = [[NSMutableDictionary alloc] initWithCapacity: " << size << "];" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "if (![inProtocol readSetBeginReturningElementType: NULL size: &" << size << " error: __thriftError]) return NO;" 
+                << endl; 
+    indent(out) << "NSMutableSet * " << fieldName 
+                << " = [[NSMutableSet alloc] initWithCapacity: " << size << "];" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "if (![inProtocol readListBeginReturningElementType: NULL size: &" << size << " error: __thriftError]) return NO;" 
+                << endl; 
+    indent(out) << "NSMutableArray * " << fieldName 
+                << " = [[NSMutableArray alloc] initWithCapacity: " << size << "];" << endl; 
+  } 
+  // FIXME - the code above does not verify that the element types of 
+  // the containers being read match the element types of the 
+  // containers we are reading into.  Does that matter? 
+ 
+  // For loop iterates over elements 
+  string i = tmp("_i"); 
+  indent(out) << "int " << i << ";" << endl << indent() << "for (" << i << " = 0; " << i << " < " 
+              << size << "; " 
+              << "++" << i << ")" << endl; 
+ 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    generate_deserialize_map_element(out, (t_map*)ttype, fieldName); 
+  } else if (ttype->is_set()) { 
+    generate_deserialize_set_element(out, (t_set*)ttype, fieldName); 
+  } else if (ttype->is_list()) { 
+    generate_deserialize_list_element(out, (t_list*)ttype, fieldName); 
+  } 
+ 
+  scope_down(out); 
+ 
+  // Read container end 
+  if (ttype->is_map()) { 
+    indent(out) << "if (![inProtocol readMapEnd: __thriftError]) return NO;" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "if (![inProtocol readSetEnd: __thriftError]) return NO;" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "if (![inProtocol readListEnd: __thriftError]) return NO;" << endl; 
+  } 
+} 
+ 
+/** 
+ * Take a variable of a given type and wrap it in code to make it 
+ * suitable for putting into a container, if necessary.  Basically, 
+ * wrap scaler primitives in NSNumber objects. 
+ */ 
+string t_cocoa_generator::box(t_type* ttype, string field_name) { 
+ 
+  ttype = get_true_type(ttype); 
+  if (ttype->is_enum()) { 
+    return "@(" + field_name + ")"; 
+  } else if (ttype->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base(); 
+    switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "can't box void"; 
+      case t_base_type::TYPE_BOOL: 
+      case t_base_type::TYPE_I8: 
+      case t_base_type::TYPE_I16: 
+      case t_base_type::TYPE_I32: 
+      case t_base_type::TYPE_I64: 
+      case t_base_type::TYPE_DOUBLE: 
+        return "@(" + field_name + ")"; 
+      default: 
+        break; 
+    } 
+  } 
+ 
+  // do nothing 
+  return field_name; 
+} 
+ 
+/** 
+ * Extracts the actual value from a boxed value 
+ */ 
+string t_cocoa_generator::unbox(t_type* ttype, string field_name) { 
+  ttype = get_true_type(ttype); 
+  if (ttype->is_enum()) { 
+    return "[" + field_name + " intValue]"; 
+  } else if (ttype->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base(); 
+    switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "can't unbox void"; 
+      case t_base_type::TYPE_BOOL: 
+        return "[" + field_name + " boolValue]"; 
+      case t_base_type::TYPE_I8: 
+        return "((SInt8)[" + field_name + " charValue])"; 
+      case t_base_type::TYPE_I16: 
+        return "((SInt16)[" + field_name + " shortValue])"; 
+      case t_base_type::TYPE_I32: 
+        return "((SInt32)[" + field_name + " longValue])"; 
+      case t_base_type::TYPE_I64: 
+        return "((SInt64)[" + field_name + " longLongValue])"; 
+      case t_base_type::TYPE_DOUBLE: 
+        return "[" + field_name + " doubleValue]"; 
+      default: 
+        break; 
+    } 
+  } 
+ 
+  // do nothing 
+  return field_name; 
+} 
+ 
+/** 
+ * Generates code to deserialize a map element 
+ */ 
+void t_cocoa_generator::generate_deserialize_map_element(ostream& out, 
+                                                         t_map* tmap, 
+                                                         string fieldName) { 
+  string key = tmp("_key"); 
+  string val = tmp("_val"); 
+  t_type* keyType = tmap->get_key_type(); 
+  t_type* valType = tmap->get_val_type(); 
+  t_field fkey(keyType, key); 
+  t_field fval(valType, val); 
+ 
+  generate_deserialize_field(out, &fkey, key); 
+  generate_deserialize_field(out, &fval, val); 
+ 
+  indent(out) << "[" << fieldName << " setObject: " << box(valType, val) 
+              << " forKey: " << box(keyType, key) << "];" << endl; 
+} 
+ 
+/** 
+ * Deserializes a set element 
+ */ 
+void t_cocoa_generator::generate_deserialize_set_element(ostream& out, 
+                                                         t_set* tset, 
+                                                         string fieldName) { 
+  string elem = tmp("_elem"); 
+  t_type* type = tset->get_elem_type(); 
+  t_field felem(type, elem); 
+ 
+  generate_deserialize_field(out, &felem, elem); 
+ 
+  indent(out) << "[" << fieldName << " addObject: " << box(type, elem) << "];" << endl; 
+} 
+ 
+/** 
+ * Deserializes a list element 
+ */ 
+void t_cocoa_generator::generate_deserialize_list_element(ostream& out, 
+                                                          t_list* tlist, 
+                                                          string fieldName) { 
+  string elem = tmp("_elem"); 
+  t_type* type = tlist->get_elem_type(); 
+  t_field felem(type, elem); 
+ 
+  generate_deserialize_field(out, &felem, elem); 
+ 
+  indent(out) << "[" << fieldName << " addObject: " << box(type, elem) << "];" << endl; 
+} 
+ 
+/** 
+ * Serializes a field of any type. 
+ * 
+ * @param tfield The field to serialize 
+ * @param fieldName Name to of the variable holding the field 
+ */ 
+void t_cocoa_generator::generate_serialize_field(ostream& out, t_field* tfield, string fieldName) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+ 
+  // Do nothing for void types 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + tfield->get_name(); 
+  } 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_serialize_struct(out, (t_struct*)type, fieldName); 
+  } else if (type->is_container()) { 
+    generate_serialize_container(out, type, fieldName); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+    indent(out) << "if (![outProtocol "; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + fieldName; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "writeBinary: " << fieldName << " error: __thriftError]"; 
+        } else { 
+          out << "writeString: " << fieldName << " error: __thriftError]"; 
+        } 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "writeBool: " << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "writeByte: (UInt8)" << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "writeI16: " << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "writeI32: " << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "writeI64: " << fieldName << " error: __thriftError]"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "writeDouble: " << fieldName << " error: __thriftError]"; 
+        break; 
+      default: 
+        throw "compiler error: no Objective-C name for base type " 
+            + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      out << "writeI32: " << fieldName << " error: __thriftError]"; 
+    } 
+    out << ") return NO;" << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s' TYPE '%s'\n", 
+           tfield->get_name().c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+/** 
+ * Serialize a struct. 
+ * 
+ * @param tstruct The struct to serialize 
+ * @param fieldName Name of variable holding struct 
+ */ 
+void t_cocoa_generator::generate_serialize_struct(ostream& out, 
+                                                  t_struct* tstruct, 
+                                                  string fieldName) { 
+  (void)tstruct; 
+  out << indent() << "if (![" << fieldName << " write: outProtocol error: __thriftError]) return NO;" << endl; 
+} 
+ 
+/** 
+ * Serializes a container by writing its size then the elements. 
+ * 
+ * @param ttype  The type of container 
+ * @param fieldName Name of variable holding container 
+ */ 
+void t_cocoa_generator::generate_serialize_container(ostream& out, 
+                                                     t_type* ttype, 
+                                                     string fieldName) { 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "if (![outProtocol writeMapBeginWithKeyType: " 
+                << type_to_enum(((t_map*)ttype)->get_key_type()) 
+                << " valueType: " << type_to_enum(((t_map*)ttype)->get_val_type()) << " size: (SInt32)[" 
+                << fieldName << " count] error: __thriftError]) return NO;" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "if (![outProtocol writeSetBeginWithElementType: " 
+                << type_to_enum(((t_set*)ttype)->get_elem_type()) << " size: (SInt32)[" << fieldName 
+                << " count] error: __thriftError]) return NO;" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "if (![outProtocol writeListBeginWithElementType: " 
+                << type_to_enum(((t_list*)ttype)->get_elem_type()) << " size: (SInt32)[" << fieldName 
+                << " count] error: __thriftError]) return NO;" << endl; 
+  } 
+ 
+  string iter = tmp("_iter"); 
+  string key; 
+  if (ttype->is_map()) { 
+    key = tmp("key"); 
+    indent(out) << "NSEnumerator * " << iter << " = [" << fieldName << " keyEnumerator];" << endl; 
+    indent(out) << "id " << key << ";" << endl; 
+    indent(out) << "while ((" << key << " = [" << iter << " nextObject]))" << endl; 
+  } else if (ttype->is_set()) { 
+    key = tmp("obj"); 
+    indent(out) << "NSEnumerator * " << iter << " = [" << fieldName << " objectEnumerator];" 
+                << endl; 
+    indent(out) << "id " << key << ";" << endl; 
+    indent(out) << "while ((" << key << " = [" << iter << " nextObject]))" << endl; 
+  } else if (ttype->is_list()) { 
+    key = tmp("idx"); 
+    indent(out) << "int " << key << ";" << endl; 
+    indent(out) << "for (" << key << " = 0; " << key << " < [" << fieldName << " count]; " << key 
+                << "++)" << endl; 
+  } 
+ 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    generate_serialize_map_element(out, (t_map*)ttype, key, fieldName); 
+  } else if (ttype->is_set()) { 
+    generate_serialize_set_element(out, (t_set*)ttype, key); 
+  } else if (ttype->is_list()) { 
+    generate_serialize_list_element(out, (t_list*)ttype, key, fieldName); 
+  } 
+ 
+  scope_down(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "if (![outProtocol writeMapEnd: __thriftError]) return NO;" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "if (![outProtocol writeSetEnd: __thriftError]) return NO;" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "if (![outProtocol writeListEnd: __thriftError]) return NO;" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+/** 
+ * Serializes the members of a map. 
+ */ 
+void t_cocoa_generator::generate_serialize_map_element(ostream& out, 
+                                                       t_map* tmap, 
+                                                       string key, 
+                                                       string mapName) { 
+  t_field kfield(tmap->get_key_type(), key); 
+  generate_serialize_field(out, &kfield, unbox(kfield.get_type(), key)); 
+  t_field vfield(tmap->get_val_type(), "[" + mapName + " objectForKey: " + key + "]"); 
+  generate_serialize_field(out, &vfield, unbox(vfield.get_type(), vfield.get_name())); 
+} 
+ 
+/** 
+ * Serializes the members of a set. 
+ */ 
+void t_cocoa_generator::generate_serialize_set_element(ostream& out, 
+                                                       t_set* tset, 
+                                                       string elementName) { 
+  t_field efield(tset->get_elem_type(), elementName); 
+  generate_serialize_field(out, &efield, unbox(efield.get_type(), elementName)); 
+} 
+ 
+/** 
+ * Serializes the members of a list. 
+ */ 
+void t_cocoa_generator::generate_serialize_list_element(ostream& out, 
+                                                        t_list* tlist, 
+                                                        string index, 
+                                                        string listName) { 
+  t_field efield(tlist->get_elem_type(), "[" + listName + " objectAtIndex: " + index + "]"); 
+  generate_serialize_field(out, &efield, unbox(efield.get_type(), efield.get_name())); 
+} 
+ 
+/** 
+ * Returns an Objective-C name 
+ * 
+ * @param ttype The type 
+ * @param class_ref Do we want a Class reference istead of a type reference? 
+ * @return Objective-C type name, i.e. NSDictionary<Key,Value> * 
+ */ 
+string t_cocoa_generator::type_name(t_type* ttype, bool class_ref, bool needs_mutable) { 
+  if (ttype->is_typedef()) { 
+    string name = (needs_mutable && ttype->get_true_type()->is_container()) ? "Mutable" + ttype->get_name() : ttype->get_name(); 
+    t_program* program = ttype->get_program(); 
+    return program ? (program->get_namespace("cocoa") + name) : name; 
+  } 
+ 
+  string result; 
+  if (ttype->is_base_type()) { 
+    return base_type_name((t_base_type*)ttype); 
+  } else if (ttype->is_enum()) { 
+    return cocoa_prefix_ + ttype->get_name(); 
+  } else if (ttype->is_map()) { 
+    t_map *map = (t_map *)ttype; 
+    result = needs_mutable ? "NSMutableDictionary" : "NSDictionary"; 
+    result += "<" + element_type_name(map->get_key_type()) + ", " + element_type_name(map->get_val_type()) + ">"; 
+  } else if (ttype->is_set()) { 
+    t_set *set = (t_set *)ttype; 
+    result = needs_mutable ? "NSMutableSet" : "NSSet"; 
+    result += "<" + element_type_name(set->get_elem_type()) + ">"; 
+  } else if (ttype->is_list()) { 
+    t_list *list = (t_list *)ttype; 
+    result = needs_mutable ? "NSMutableArray" : "NSArray"; 
+    result += "<" + element_type_name(list->get_elem_type()) + ">"; 
+  } else { 
+    // Check for prefix 
+    t_program* program = ttype->get_program(); 
+    if (program != NULL) { 
+      result = program->get_namespace("cocoa") + ttype->get_name(); 
+    } else { 
+      result = ttype->get_name(); 
+    } 
+  } 
+ 
+  if (!class_ref) { 
+    result += " *"; 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Returns an Objective-C type name for container types 
+ * 
+ * @param ttype the type 
+ */ 
+string t_cocoa_generator::element_type_name(t_type* etype) { 
+ 
+  t_type* ttype = etype->get_true_type(); 
+ 
+  if (etype->is_typedef() && type_can_be_null(ttype)) { 
+    return type_name(etype); 
+  } 
+ 
+  string result; 
+  if (ttype->is_base_type()) { 
+    t_base_type* tbase = (t_base_type*)ttype; 
+    switch (tbase->get_base()) { 
+    case t_base_type::TYPE_STRING: 
+      if (tbase->is_binary()) { 
+        result = "NSData *"; 
+      } 
+      else { 
+        result = "NSString *"; 
+      } 
+      break; 
+    default: 
+      result = "NSNumber *"; 
+      break; 
+    } 
+  } else if (ttype->is_enum()) { 
+      result = "NSNumber *"; 
+  } else if (ttype->is_map()) { 
+    t_map *map = (t_map *)ttype; 
+    result = "NSDictionary<" + element_type_name(map->get_key_type()) + ", " + element_type_name(map->get_val_type()) + "> *"; 
+  } else if (ttype->is_set()) { 
+    t_set *set = (t_set *)ttype; 
+    result = "NSSet<" + element_type_name(set->get_elem_type()) + "> *"; 
+  } else if (ttype->is_list()) { 
+    t_list *list = (t_list *)ttype; 
+    result = "NSArray<" + element_type_name(list->get_elem_type()) + "> *"; 
+  } else if (ttype->is_struct() || ttype->is_xception()) { 
+    result = cocoa_prefix_ + ttype->get_name() + " *"; 
+  } 
+ 
+  return result; 
+} 
+ 
+/** 
+ * Returns the Objective-C type that corresponds to the thrift type. 
+ * 
+ * @param tbase The base type 
+ */ 
+string t_cocoa_generator::base_type_name(t_base_type* type) { 
+  t_base_type::t_base tbase = type->get_base(); 
+ 
+  switch (tbase) { 
+  case t_base_type::TYPE_VOID: 
+    return "void"; 
+  case t_base_type::TYPE_STRING: 
+    if (type->is_binary()) { 
+      return "NSData *"; 
+    } else { 
+      return "NSString *"; 
+    } 
+  case t_base_type::TYPE_BOOL: 
+    return "BOOL"; 
+  case t_base_type::TYPE_I8: 
+    return "SInt8"; 
+  case t_base_type::TYPE_I16: 
+    return "SInt16"; 
+  case t_base_type::TYPE_I32: 
+    return "SInt32"; 
+  case t_base_type::TYPE_I64: 
+    return "SInt64"; 
+  case t_base_type::TYPE_DOUBLE: 
+    return "double"; 
+  default: 
+    throw "compiler error: no Objective-C name for base type " + t_base_type::t_base_name(tbase); 
+  } 
+} 
+ 
+/** 
+ * Prints the value of a constant with the given type. Note that type checking 
+ * is NOT performed in this function as it is always run beforehand using the 
+ * validate_types method in main.cc 
+ */ 
+void t_cocoa_generator::print_const_value(ostream& out, 
+                                          string name, 
+                                          t_type* type, 
+                                          t_const_value* value, 
+                                          bool defval) { 
+  type = get_true_type(type); 
+ 
+  if (type->is_base_type()) { 
+    string v2 = render_const_value(out, type, value); 
+    indent(out); 
+    if (defval) 
+      out << type_name(type) << " "; 
+    out << name << " = " << v2 << ";" << endl << endl; 
+  } else if (type->is_enum()) { 
+    indent(out); 
+    if (defval) 
+      out << type_name(type) << " "; 
+    out << name << " = " << render_const_value(out, type, value) << ";" << endl << endl; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    indent(out); 
+    const vector<t_field*>& fields = ((t_struct*)type)->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    if (defval) 
+      out << type_name(type) << " "; 
+    out << name << " = [" << type_name(type, true) << " new];" 
+        << endl; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      t_type* field_type = NULL; 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field_type = (*f_iter)->get_type(); 
+        } 
+      } 
+      if (field_type == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string(); 
+      } 
+      string val = render_const_value(out, field_type, v_iter->second); 
+      std::string cap_name = capitalize(v_iter->first->get_string()); 
+      indent(out) << "[" << name << " set" << cap_name << ":" << val << "];" << endl; 
+    } 
+  } else if (type->is_map()) { 
+    ostringstream mapout; 
+    indent(mapout); 
+    t_type* ktype = ((t_map*)type)->get_key_type(); 
+    t_type* vtype = ((t_map*)type)->get_val_type(); 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    if (defval) 
+      mapout << type_name(type) << " "; 
+    mapout << name << " = @{"; 
+    for (v_iter = val.begin(); v_iter != val.end();) { 
+      mapout << render_const_value(out, ktype, v_iter->first, true) << ": " 
+          << render_const_value(out, vtype, v_iter->second, true); 
+      if (++v_iter != val.end()) { 
+        mapout << ", "; 
+      } 
+    } 
+    mapout << "}"; 
+    out << mapout.str(); 
+  } else if (type->is_list()) { 
+    ostringstream listout; 
+    indent(listout); 
+    t_type* etype = ((t_list*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    if (defval) 
+      listout << type_name(type) << " "; 
+    listout << name << " = @["; 
+    for (v_iter = val.begin(); v_iter != val.end();) { 
+      listout << render_const_value(out, etype, *v_iter, true); 
+      if (++v_iter != val.end()) { 
+        listout << ", "; 
+      } 
+    } 
+    listout << "]"; 
+    out << listout.str(); 
+  } else if (type->is_set()) { 
+    ostringstream setout; 
+    indent(setout); 
+    t_type* etype = ((t_set*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    if (defval) 
+      setout << type_name(type) << " "; 
+    setout << name << " = [NSSet setWithArray:@["; 
+    for (v_iter = val.begin(); v_iter != val.end();) { 
+      setout << render_const_value(out, etype, *v_iter, true); 
+      if (++v_iter != val.end()) { 
+        setout << ", "; 
+      } 
+    } 
+    setout << "]]"; 
+    out << setout.str(); 
+  } else { 
+    throw "compiler error: no const of type " + type->get_name(); 
+  } 
+} 
+ 
+string t_cocoa_generator::render_const_value(ostream& out, 
+                                             t_type* type, 
+                                             t_const_value* value, 
+                                             bool box_it) { 
+  type = get_true_type(type); 
+  std::ostringstream render; 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      // We must handle binary constant but the syntax of IDL defines 
+      // nothing about binary constant. 
+      //   if type->is_binary()) 
+      //      // binary code 
+      render << "@\"" << get_escaped_string(value) << '"'; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      render << ((value->get_integer() > 0) ? "YES" : "NO"); 
+      break; 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+    case t_base_type::TYPE_I64: 
+      render << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      if (value->get_type() == t_const_value::CV_INTEGER) { 
+        render << value->get_integer(); 
+      } else { 
+        render << value->get_double(); 
+      } 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else if (type->is_enum()) { 
+    render << value->get_integer(); 
+  } else { 
+    string t = tmp("tmp"); 
+    print_const_value(out, t, type, value, true); 
+    out << ";" << endl; 
+    render << t; 
+  } 
+ 
+  if (box_it) { 
+    return box(type, render.str()); 
+  } 
+  return render.str(); 
+} 
+ 
+#if 0 
+/** 
+ORIGINAL 
+ * Spit out code that evaluates to the specified constant value. 
+ */ 
+string t_cocoa_generator::render_const_value(string name, 
+                                             t_type* type, 
+                                             t_const_value* value, 
+                                             bool box_it) { 
+  type = get_true_type(type); 
+  std::ostringstream render; 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      render << "@\"" << get_escaped_string(value) << '"'; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      render << ((value->get_integer() > 0) ? "YES" : "NO"); 
+      break; 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+    case t_base_type::TYPE_I64: 
+      render << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      if (value->get_type() == t_const_value::CV_INTEGER) { 
+        render << value->get_integer(); 
+      } else { 
+        render << value->get_double(); 
+      } 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else if (type->is_enum()) { 
+    render << value->get_integer(); 
+  } else if (type->is_struct() || type->is_xception()) { 
+    const vector<t_field*>& fields = ((t_struct*)type)->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    if (val.size() > 0) 
+      render << "[[" << type_name(type, true) << " alloc] initWith"; 
+    else 
+      render << "[[" << type_name(type, true) << " alloc] init"; 
+    bool first = true; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      // FIXME The generated code does not match with initWithXXX 
+      //       initializer and causes compile error. 
+      //       Try: test/DebugProtoTest.thrift and test/SmallTest.thrift 
+      t_type* field_type = NULL; 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field_type = (*f_iter)->get_type(); 
+        } 
+      } 
+      if (field_type == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string(); 
+      } 
+      if (first) { 
+        render << capitalize(v_iter->first->get_string()); 
+        first = false; 
+      } else { 
+        render << " " << v_iter->first->get_string(); 
+      } 
+      render << ": " << render_const_value(name, field_type, v_iter->second); 
+    } 
+    render << "]"; 
+  } else if (type->is_map()) { 
+    render << "[[NSDictionary alloc] initWithObjectsAndKeys: "; 
+    t_type* ktype = ((t_map*)type)->get_key_type(); 
+    t_type* vtype = ((t_map*)type)->get_val_type(); 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    bool first = true; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string key = render_const_value(name, ktype, v_iter->first, true); 
+      string val = render_const_value(name, vtype, v_iter->second, true); 
+      if (first) { 
+        first = false; 
+      } else { 
+        render << ", "; 
+      } 
+      render << val << ", " << key; 
+    } 
+    if (first) 
+      render << " nil]"; 
+    else 
+      render << ", nil]"; 
+  } else if (type->is_list()) { 
+    render << "[[NSArray alloc] initWithObjects: "; 
+    t_type * etype = ((t_list*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    bool first = true; 
+    vector<t_const_value*>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      if (first) { 
+        first = false; 
+      } else { 
+        render << ", "; 
+      } 
+      render << render_const_value(name, etype, *v_iter, true); 
+    } 
+    if (first) 
+      render << " nil]"; 
+    else 
+      render << ", nil]"; 
+  } else if (type->is_set()) { 
+    render << "[[NSSet alloc] initWithObjects: "; 
+    t_type * etype = ((t_set*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    bool first = true; 
+    vector<t_const_value*>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      if (first) { 
+        first = false; 
+      } else { 
+        render << ", "; 
+      } 
+      render << render_const_value(name, etype, *v_iter, true); 
+    } 
+    if (first) 
+      render << " nil]"; 
+    else 
+      render << ", nil]"; 
+  } else { 
+    throw "don't know how to render constant for type: " + type->get_name(); 
+  } 
+ 
+  if (box_it) { 
+    return box(type, render.str()); 
+  } 
+ 
+  return render.str(); 
+} 
+#endif 
+ 
+/** 
+ * Declares an Objective-C 2.0 property. 
+ * 
+ * @param tfield The field to declare a property for 
+ */ 
+string t_cocoa_generator::declare_property(t_field* tfield) { 
+  std::ostringstream render; 
+  render << "@property ("; 
+ 
+  if (type_can_be_copy(tfield->get_type())) { 
+    render << "copy, "; 
+  } else if (type_can_be_null(tfield->get_type())) { 
+    render << "strong, "; 
+  } else { 
+    render << "assign, "; 
+  } 
+ 
+  render << "nonatomic) " << type_name(tfield->get_type(), false, true) << " " 
+  << tfield->get_name() << ";"; 
+ 
+  // Check if the property name is an Objective-C return +1 count signal 
+  if ((tfield->get_name().length() >= 3 && tfield->get_name().substr(0,3) == "new") || 
+      (tfield->get_name().length() >= 6 && tfield->get_name().substr(0,6) == "create") || 
+      (tfield->get_name().length() >= 5 && tfield->get_name().substr(0,5) == "alloc")) { 
+    // Let Objective-C know not to return +1 for object pointers 
+    if (type_can_be_null(tfield->get_type())) { 
+      render << endl; 
+      render << "- (" + type_name(tfield->get_type()) + ") " + decapitalize(tfield->get_name()) + " __attribute__((objc_method_family(none)));"; 
+    } 
+  } 
+ 
+  return render.str(); 
+} 
+ 
+/** 
+ * Declares an Objective-C 2.0 property. 
+ * 
+ * @param tfield The field to declare a property for 
+ */ 
+string t_cocoa_generator::declare_property_isset(t_field* tfield) { 
+  return "@property (assign, nonatomic) BOOL " + decapitalize(tfield->get_name()) + "IsSet;"; 
+} 
+ 
+/** 
+ * Declares property unset method. 
+ * 
+ * @param tfield The field to declare a property for 
+ */ 
+string t_cocoa_generator::declare_property_unset(t_field* tfield) { 
+  return "- (void) unset" + capitalize(tfield->get_name()) + ";"; 
+} 
+ 
+/** 
+ * Renders the early out return statement 
+ * 
+ * @param tfunction Function definition 
+ * @return String of rendered invalid return statment 
+ */ 
+string t_cocoa_generator::invalid_return_statement(t_function *tfunction) { 
+  if ((tfunction->get_returntype()->is_void())) { 
+    return "return NO;"; 
+  } 
+  return "return nil;"; 
+} 
+ 
+/** 
+ * Renders a function signature 
+ * 
+ * @param tfunction Function definition 
+ * @return String of rendered function definition 
+ */ 
+string t_cocoa_generator::function_signature(t_function* tfunction, bool include_error) { 
+  t_type* ttype = tfunction->get_returntype(); 
+  string result; 
+  if (ttype->is_void()) { 
+    result = "(BOOL)"; 
+  } 
+  else if (type_can_be_null(ttype)) { 
+    result = "(" + type_name(ttype) + ")"; 
+  } 
+  else { 
+    result = "(NSNumber *)"; 
+  } 
+  result += " " + tfunction->get_name() + argument_list(tfunction->get_arglist(), "", include_error); 
+  return result; 
+} 
+ 
+/** 
+ * Renders a function signature that returns asynchronously instead of 
+ * literally returning. 
+ * 
+ * @param tfunction Function definition 
+ * @return String of rendered function definition 
+ */ 
+string t_cocoa_generator::async_function_signature(t_function* tfunction, bool include_error) { 
+  t_type* ttype = tfunction->get_returntype(); 
+  t_struct* targlist = tfunction->get_arglist(); 
+  string response_param = "void (^)(" + ((ttype->is_void()) ? "" : type_name(ttype)) + ")"; 
+  std::string result = "(void) " + tfunction->get_name() + argument_list(tfunction->get_arglist(), "", include_error) 
+  + (targlist->get_members().size() ? " response" : "") + ": (" 
+  + response_param + ") responseBlock " 
+  + "failure : (TAsyncFailureBlock) failureBlock"; 
+  return result; 
+} 
+ 
+/** 
+ * Renders a function signature that returns a promise instead of 
+ * literally returning. 
+ * 
+ * @param tfunction Function definition 
+ * @return String of rendered function definition 
+ */ 
+string t_cocoa_generator::promise_function_signature(t_function* tfunction) { 
+  return "(AnyPromise *) " + tfunction->get_name() + argument_list(tfunction->get_arglist(), "", false); 
+} 
+ 
+/** 
+ * Renders a colon separated list of types and names, suitable for an 
+ * objective-c parameter list 
+ */ 
+string t_cocoa_generator::argument_list(t_struct* tstruct, string protocol_name, bool include_error) { 
+  string result = ""; 
+  bool include_protocol = !protocol_name.empty(); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    string argPrefix = ""; 
+    if (first) { 
+      first = false; 
+    } else { 
+      argPrefix = (*f_iter)->get_name(); 
+      result += " "; 
+    } 
+    result += argPrefix + ": (" + type_name((*f_iter)->get_type()) + ") " + (*f_iter)->get_name(); 
+  } 
+  if (include_protocol) { 
+    if (!first) { 
+      result += " protocol"; 
+    } 
+    result += ": (id<TProtocol>) " + protocol_name; 
+    first = false; 
+  } 
+  if (include_error) { 
+    if (!first) { 
+      result += " error"; 
+    } 
+    result += ": (NSError *__autoreleasing *)__thriftError"; 
+    first = false; 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Converts the parse type to an Objective-C enum string for the given type. 
+ */ 
+string t_cocoa_generator::type_to_enum(t_type* type) { 
+  type = get_true_type(type); 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "NO T_VOID CONSTRUCT"; 
+    case t_base_type::TYPE_STRING: 
+      return "TTypeSTRING"; 
+    case t_base_type::TYPE_BOOL: 
+      return "TTypeBOOL"; 
+    case t_base_type::TYPE_I8: 
+      return "TTypeBYTE"; 
+    case t_base_type::TYPE_I16: 
+      return "TTypeI16"; 
+    case t_base_type::TYPE_I32: 
+      return "TTypeI32"; 
+    case t_base_type::TYPE_I64: 
+      return "TTypeI64"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "TTypeDOUBLE"; 
+    } 
+  } else if (type->is_enum()) { 
+    return "TTypeI32"; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    return "TTypeSTRUCT"; 
+  } else if (type->is_map()) { 
+    return "TTypeMAP"; 
+  } else if (type->is_set()) { 
+    return "TTypeSET"; 
+  } else if (type->is_list()) { 
+    return "TTypeLIST"; 
+  } 
+ 
+  throw "INVALID TYPE IN type_to_enum: " + type->get_name(); 
+} 
+ 
+/** 
+ * Returns a format string specifier for the supplied parse type. 
+ */ 
+string t_cocoa_generator::format_string_for_type(t_type* type) { 
+  type = get_true_type(type); 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "NO T_VOID CONSTRUCT"; 
+    case t_base_type::TYPE_STRING: 
+      return "\\\"%@\\\""; 
+    case t_base_type::TYPE_BOOL: 
+      return "%i"; 
+    case t_base_type::TYPE_I8: 
+      return "%i"; 
+    case t_base_type::TYPE_I16: 
+      return "%hi"; 
+    case t_base_type::TYPE_I32: 
+      return "%i"; 
+    case t_base_type::TYPE_I64: 
+      return "%qi"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "%f"; 
+    } 
+  } else if (type->is_enum()) { 
+    return "%i"; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    return "%@"; 
+  } else if (type->is_map()) { 
+    return "%@"; 
+  } else if (type->is_set()) { 
+    return "%@"; 
+  } else if (type->is_list()) { 
+    return "%@"; 
+  } 
+ 
+  throw "INVALID TYPE IN format_string_for_type: " + type->get_name(); 
+} 
+ 
+/** 
+ * Returns a format cast for the supplied parse type. 
+ */ 
+string t_cocoa_generator::format_cast_for_type(t_type* type) { 
+  type = get_true_type(type); 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "NO T_VOID CONSTRUCT"; 
+    case t_base_type::TYPE_STRING: 
+      return ""; // "\\\"%@\\\""; 
+    case t_base_type::TYPE_BOOL: 
+      return ""; // "%i"; 
+    case t_base_type::TYPE_I8: 
+      return ""; // "%i"; 
+    case t_base_type::TYPE_I16: 
+      return ""; // "%hi"; 
+    case t_base_type::TYPE_I32: 
+      return "(int)"; // "%i"; 
+    case t_base_type::TYPE_I64: 
+      return ""; // "%qi"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return ""; // "%f"; 
+    } 
+  } else if (type->is_enum()) { 
+    return "(int)"; // "%i"; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    return ""; // "%@"; 
+  } else if (type->is_map()) { 
+    return ""; // "%@"; 
+  } else if (type->is_set()) { 
+    return ""; // "%@"; 
+  } else if (type->is_list()) { 
+    return ""; // "%@"; 
+  } 
+ 
+  throw "INVALID TYPE IN format_cast_for_type: " + type->get_name(); 
+} 
+ 
+/** 
+ * Generate a call to a field's setter. 
+ * 
+ * @param tfield Field the setter is being called on 
+ * @param fieldName Name of variable to pass to setter 
+ */ 
+ 
+string t_cocoa_generator::call_field_setter(t_field* tfield, string fieldName) { 
+  return "self." + tfield->get_name() + " = " + fieldName + ";"; 
+} 
+ 
+THRIFT_REGISTER_GENERATOR( 
+    cocoa, 
+    "Cocoa", 
+    "    log_unexpected:  Log every time an unexpected field ID or type is encountered.\n" 
+    "    debug_descriptions:\n" 
+    "                     Allow use of debugDescription so the app can add description via a cateogory/extension\n" 
+    "    validate_required:\n" 
+    "                     Throws exception if any required field is not set.\n" 
+    "    async_clients:   Generate clients which invoke asynchronously via block syntax.\n" 
+    "    pods:            Generate imports in Cocopods framework format.\n" 
+    "    promise_kit:     Generate clients which invoke asynchronously via promises.\n") 

contrib/restricted/thrift/compiler/thrift/generate/t_cpp_generator.cc

@@ -1,4489 +1,4489 @@
-/*
- * 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.
- *
- * Contains some contributions under the Thrift Software License.
- * Please see doc/old-thrift-license.txt in the Thrift distribution for
- * details.
- */
-
-#include <cassert>
-
-#include <fstream>
-#include <iomanip>
-#include <iostream>
-#include <limits>
-#include <sstream>
-#include <string>
-#include <vector>
-
-#include <sys/stat.h>
-
-#include "thrift/platform.h"
-#include "thrift/generate/t_oop_generator.h"
-
-using std::map;
-using std::ofstream;
-using std::ostream;
-using std::string;
-using std::vector;
-
-static const string endl = "\n"; // avoid ostream << std::endl flushes
-
-/**
- * C++ code generator. This is legitimacy incarnate.
- *
- */
-class t_cpp_generator : public t_oop_generator {
-public:
-  t_cpp_generator(t_program* program,
-                  const std::map<std::string, std::string>& parsed_options,
-                  const std::string& option_string)
-    : t_oop_generator(program) {
-    (void)option_string;
-    std::map<std::string, std::string>::const_iterator iter;
-
-
-    gen_pure_enums_ = false;
-    use_include_prefix_ = false;
-    gen_cob_style_ = false;
-    gen_no_client_completion_ = false;
-    gen_no_default_operators_ = false;
-    gen_templates_ = false;
-    gen_templates_only_ = false;
-    gen_moveable_ = false;
-    gen_no_ostream_operators_ = false;
-    gen_no_skeleton_ = false;
-
-    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
-      if( iter->first.compare("pure_enums") == 0) {
-        gen_pure_enums_ = true;
-      } else if( iter->first.compare("include_prefix") == 0) {
-        use_include_prefix_ = true;
-      } else if( iter->first.compare("cob_style") == 0) {
-        gen_cob_style_ = true;
-      } else if( iter->first.compare("no_client_completion") == 0) {
-        gen_no_client_completion_ = true;
-      } else if( iter->first.compare("no_default_operators") == 0) {
-        gen_no_default_operators_ = true;
-      } else if( iter->first.compare("templates") == 0) {
-        gen_templates_ = true;
-        gen_templates_only_ = (iter->second == "only");
-      } else if( iter->first.compare("moveable_types") == 0) {
-        gen_moveable_ = true;
-      } else if ( iter->first.compare("no_ostream_operators") == 0) {
-        gen_no_ostream_operators_ = true;
-      } else if ( iter->first.compare("no_skeleton") == 0) {
-        gen_no_skeleton_ = true;
-      } else {
-        throw "unknown option cpp:" + iter->first;
-      }
-    }
-
-    out_dir_base_ = "gen-cpp";
-  }
-
-  /**
-   * Init and close methods
-   */
-
-  void init_generator();
-  void close_generator();
-
-  void generate_consts(std::vector<t_const*> consts);
-
-  /**
-   * Program-level generation functions
-   */
-
-  void generate_typedef(t_typedef* ttypedef);
-  void generate_enum(t_enum* tenum);
-  void generate_enum_ostream_operator_decl(std::ostream& out, t_enum* tenum);
-  void generate_enum_ostream_operator(std::ostream& out, t_enum* tenum);
-  void generate_forward_declaration(t_struct* tstruct);
-  void generate_struct(t_struct* tstruct) { generate_cpp_struct(tstruct, false); }
-  void generate_xception(t_struct* txception) { generate_cpp_struct(txception, true); }
-  void generate_cpp_struct(t_struct* tstruct, bool is_exception);
-
-  void generate_service(t_service* tservice);
-
-  void print_const_value(std::ostream& out, std::string name, t_type* type, t_const_value* value);
-  std::string render_const_value(std::ostream& out,
-                                 std::string name,
-                                 t_type* type,
-                                 t_const_value* value);
-
-  void generate_struct_declaration(std::ostream& out,
-                                   t_struct* tstruct,
-                                   bool is_exception = false,
-                                   bool pointers = false,
-                                   bool read = true,
-                                   bool write = true,
-                                   bool swap = false,
-                                   bool is_user_struct = false);
-  void generate_struct_definition(std::ostream& out,
-                                  std::ostream& force_cpp_out,
-                                  t_struct* tstruct,
-                                  bool setters = true,
-                                  bool is_user_struct = false);
-  void generate_copy_constructor(std::ostream& out, t_struct* tstruct, bool is_exception);
-  void generate_move_constructor(std::ostream& out, t_struct* tstruct, bool is_exception);
-  void generate_constructor_helper(std::ostream& out,
-                                   t_struct* tstruct,
-                                   bool is_excpetion,
-                                   bool is_move);
-  void generate_assignment_operator(std::ostream& out, t_struct* tstruct);
-  void generate_move_assignment_operator(std::ostream& out, t_struct* tstruct);
-  void generate_assignment_helper(std::ostream& out, t_struct* tstruct, bool is_move);
-  void generate_struct_reader(std::ostream& out, t_struct* tstruct, bool pointers = false);
-  void generate_struct_writer(std::ostream& out, t_struct* tstruct, bool pointers = false);
-  void generate_struct_result_writer(std::ostream& out, t_struct* tstruct, bool pointers = false);
-  void generate_struct_swap(std::ostream& out, t_struct* tstruct);
-  void generate_struct_print_method(std::ostream& out, t_struct* tstruct);
-  void generate_exception_what_method(std::ostream& out, t_struct* tstruct);
-
-  /**
-   * Service-level generation functions
-   */
-
-  void generate_service_interface(t_service* tservice, string style);
-  void generate_service_interface_factory(t_service* tservice, string style);
-  void generate_service_null(t_service* tservice, string style);
-  void generate_service_multiface(t_service* tservice);
-  void generate_service_helpers(t_service* tservice);
-  void generate_service_client(t_service* tservice, string style);
-  void generate_service_processor(t_service* tservice, string style);
-  void generate_service_skeleton(t_service* tservice);
-  void generate_process_function(t_service* tservice,
-                                 t_function* tfunction,
-                                 string style,
-                                 bool specialized = false);
-  void generate_function_helpers(t_service* tservice, t_function* tfunction);
-  void generate_service_async_skeleton(t_service* tservice);
-
-  /**
-   * Serialization constructs
-   */
-
-  void generate_deserialize_field(std::ostream& out,
-                                  t_field* tfield,
-                                  std::string prefix = "",
-                                  std::string suffix = "");
-
-  void generate_deserialize_struct(std::ostream& out,
-                                   t_struct* tstruct,
-                                   std::string prefix = "",
-                                   bool pointer = false);
-
-  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-
-  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = "");
-
-  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = "");
-
-  void generate_deserialize_list_element(std::ostream& out,
-                                         t_list* tlist,
-                                         std::string prefix,
-                                         bool push_back,
-                                         std::string index);
-
-  void generate_serialize_field(std::ostream& out,
-                                t_field* tfield,
-                                std::string prefix = "",
-                                std::string suffix = "");
-
-  void generate_serialize_struct(std::ostream& out,
-                                 t_struct* tstruct,
-                                 std::string prefix = "",
-                                 bool pointer = false);
-
-  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-
-  void generate_serialize_map_element(std::ostream& out, t_map* tmap, std::string iter);
-
-  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter);
-
-  void generate_serialize_list_element(std::ostream& out, t_list* tlist, std::string iter);
-
-  void generate_function_call(ostream& out,
-                              t_function* tfunction,
-                              string target,
-                              string iface,
-                              string arg_prefix);
-  /*
-   * Helper rendering functions
-   */
-
-  std::string namespace_prefix(std::string ns);
-  std::string namespace_open(std::string ns);
-  std::string namespace_close(std::string ns);
-  std::string type_name(t_type* ttype, bool in_typedef = false, bool arg = false);
-  std::string base_type_name(t_base_type::t_base tbase);
-  std::string declare_field(t_field* tfield,
-                            bool init = false,
-                            bool pointer = false,
-                            bool constant = false,
-                            bool reference = false);
-  std::string function_signature(t_function* tfunction,
-                                 std::string style,
-                                 std::string prefix = "",
-                                 bool name_params = true);
-  std::string cob_function_signature(t_function* tfunction,
-                                     std::string prefix = "",
-                                     bool name_params = true);
-  std::string argument_list(t_struct* tstruct, bool name_params = true, bool start_comma = false);
-  std::string type_to_enum(t_type* ttype);
-
-  void generate_enum_constant_list(std::ostream& f,
-                                   const vector<t_enum_value*>& constants,
-                                   const char* prefix,
-                                   const char* suffix,
-                                   bool include_values);
-
-  void generate_struct_ostream_operator_decl(std::ostream& f, t_struct* tstruct);
-  void generate_struct_ostream_operator(std::ostream& f, t_struct* tstruct);
-  void generate_struct_print_method_decl(std::ostream& f, t_struct* tstruct);
-  void generate_exception_what_method_decl(std::ostream& f,
-                                           t_struct* tstruct,
-                                           bool external = false);
-
-  bool is_reference(t_field* tfield) { return tfield->get_reference(); }
-
-  bool is_complex_type(t_type* ttype) {
-    ttype = get_true_type(ttype);
-
-    return ttype->is_container() || ttype->is_struct() || ttype->is_xception()
-           || (ttype->is_base_type()
-               && (((t_base_type*)ttype)->get_base() == t_base_type::TYPE_STRING));
-  }
-
-  void set_use_include_prefix(bool use_include_prefix) { use_include_prefix_ = use_include_prefix; }
-
-  /**
-   * The compiler option "no_thrift_ostream_impl" can be used to prevent
-   * the compiler from emitting implementations for operator <<.  In this
-   * case the consuming application must provide any needed to build.
-   *
-   * To disable this on a per structure bases, one can alternatively set
-   * the annotation "cpp.customostream" to prevent thrift from emitting an
-   * operator << (std::ostream&).
-   *
-   * See AnnotationTest for validation of this annotation feature.
-   */
-  bool has_custom_ostream(t_type* ttype) const {
-    return (gen_no_ostream_operators_) ||
-           (ttype->annotations_.find("cpp.customostream") != ttype->annotations_.end());
-  }
-
-private:
-  /**
-   * Returns the include prefix to use for a file generated by program, or the
-   * empty string if no include prefix should be used.
-   */
-  std::string get_include_prefix(const t_program& program) const;
-
-  /**
-   * True if we should generate pure enums for Thrift enums, instead of wrapper classes.
-   */
-  bool gen_pure_enums_;
-
-  /**
-   * True if we should generate templatized reader/writer methods.
-   */
-  bool gen_templates_;
-
-  /**
-   * True iff we should generate process function pointers for only templatized
-   * reader/writer methods.
-   */
-  bool gen_templates_only_;
-
-  /**
-   * True if we should generate move constructors & assignment operators.
-   */
-  bool gen_moveable_;
-
-  /**
-   * True if we should generate ostream definitions
-   */
-  bool gen_no_ostream_operators_;
-
-  /**
-   * True iff we should use a path prefix in our #include statements for other
-   * thrift-generated header files.
-   */
-  bool use_include_prefix_;
-
-  /**
-   * True if we should generate "Continuation OBject"-style classes as well.
-   */
-  bool gen_cob_style_;
-
-  /**
-   * True if we should omit calls to completion__() in CobClient class.
-   */
-  bool gen_no_client_completion_;
-
-  /**
-   * True if we should omit generating the default opeartors ==, != and <.
-   */
-  bool gen_no_default_operators_;
-
-   /**
-   * True if we should generate skeleton.
-   */
-  bool gen_no_skeleton_;
-
-  /**
-   * Strings for namespace, computed once up front then used directly
-   */
-
-  std::string ns_open_;
-  std::string ns_close_;
-
-  /**
-   * File streams, stored here to avoid passing them as parameters to every
-   * function.
-   */
-
-  ofstream_with_content_based_conditional_update f_types_;
-  ofstream_with_content_based_conditional_update f_types_impl_;
-  ofstream_with_content_based_conditional_update f_types_tcc_;
-  ofstream_with_content_based_conditional_update f_header_;
-  ofstream_with_content_based_conditional_update f_service_;
-  ofstream_with_content_based_conditional_update f_service_tcc_;
-
-  // The ProcessorGenerator is used to generate parts of the code,
-  // so it needs access to many of our protected members and methods.
-  //
-  // TODO: The code really should be cleaned up so that helper methods for
-  // writing to the output files are separate from the generator classes
-  // themselves.
-  friend class ProcessorGenerator;
-};
-
-/**
- * Prepares for file generation by opening up the necessary file output
- * streams.
- */
-void t_cpp_generator::init_generator() {
-  // Make output directory
-  MKDIR(get_out_dir().c_str());
-
-  // Make output file
-  string f_types_name = get_out_dir() + program_name_ + "_types.h";
-  f_types_.open(f_types_name);
-
-  string f_types_impl_name = get_out_dir() + program_name_ + "_types.cpp";
-  f_types_impl_.open(f_types_impl_name.c_str());
-
-  if (gen_templates_) {
-    // If we don't open the stream, it appears to just discard data,
-    // which is fine.
-    string f_types_tcc_name = get_out_dir() + program_name_ + "_types.tcc";
-    f_types_tcc_.open(f_types_tcc_name.c_str());
-  }
-
-  // Print header
-  f_types_ << autogen_comment();
-  f_types_impl_ << autogen_comment();
-  f_types_tcc_ << autogen_comment();
-
-  // Start ifndef
-  f_types_ << "#ifndef " << program_name_ << "_TYPES_H" << endl << "#define " << program_name_
-           << "_TYPES_H" << endl << endl;
-  f_types_tcc_ << "#ifndef " << program_name_ << "_TYPES_TCC" << endl << "#define " << program_name_
-               << "_TYPES_TCC" << endl << endl;
-
-  // Include base types
-  f_types_ << "#include <iosfwd>" << endl
-           << endl
-           << "#include <thrift/Thrift.h>" << endl
-           << "#include <thrift/TApplicationException.h>" << endl
-           << "#include <thrift/TBase.h>" << endl
-           << "#include <thrift/protocol/TProtocol.h>" << endl
-           << "#include <thrift/transport/TTransport.h>" << endl
-           << endl;
-  // Include C++xx compatibility header
-  f_types_ << "#include <thrift/stdcxx.h>" << endl;
-
-  // Include other Thrift includes
-  const vector<t_program*>& includes = program_->get_includes();
-  for (size_t i = 0; i < includes.size(); ++i) {
-    f_types_ << "#include \"" << get_include_prefix(*(includes[i])) << includes[i]->get_name()
-             << "_types.h\"" << endl;
-
-    // XXX(simpkins): If gen_templates_ is enabled, we currently assume all
-    // included files were also generated with templates enabled.
-    f_types_tcc_ << "#include \"" << get_include_prefix(*(includes[i])) << includes[i]->get_name()
-                 << "_types.tcc\"" << endl;
-  }
-  f_types_ << endl;
-
-  // Include custom headers
-  const vector<string>& cpp_includes = program_->get_cpp_includes();
-  for (size_t i = 0; i < cpp_includes.size(); ++i) {
-    if (cpp_includes[i][0] == '<') {
-      f_types_ << "#include " << cpp_includes[i] << endl;
-    } else {
-      f_types_ << "#include \"" << cpp_includes[i] << "\"" << endl;
-    }
-  }
-  f_types_ << endl;
-
-  // Include the types file
-  f_types_impl_ << "#include \"" << get_include_prefix(*get_program()) << program_name_
-                << "_types.h\"" << endl << endl;
-  f_types_tcc_ << "#include \"" << get_include_prefix(*get_program()) << program_name_
-               << "_types.h\"" << endl << endl;
-
-  // The swap() code needs <algorithm> for std::swap()
-  f_types_impl_ << "#include <algorithm>" << endl;
-  // for operator<<
-  f_types_impl_ << "#include <ostream>" << endl << endl;
-  f_types_impl_ << "#include <thrift/TToString.h>" << endl << endl;
-
-  // Open namespace
-  ns_open_ = namespace_open(program_->get_namespace("cpp"));
-  ns_close_ = namespace_close(program_->get_namespace("cpp"));
-
-  f_types_ << ns_open_ << endl << endl;
-
-  f_types_impl_ << ns_open_ << endl << endl;
-
-  f_types_tcc_ << ns_open_ << endl << endl;
-}
-
-/**
- * Closes the output files.
- */
-void t_cpp_generator::close_generator() {
-  // Close namespace
-  f_types_ << ns_close_ << endl << endl;
-  f_types_impl_ << ns_close_ << endl;
-  f_types_tcc_ << ns_close_ << endl << endl;
-
-  // Include the types.tcc file from the types header file,
-  // so clients don't have to explicitly include the tcc file.
-  // TODO(simpkins): Make this a separate option.
-  if (gen_templates_) {
-    f_types_ << "#include \"" << get_include_prefix(*get_program()) << program_name_
-             << "_types.tcc\"" << endl << endl;
-  }
-
-  // Close ifndef
-  f_types_ << "#endif" << endl;
-  f_types_tcc_ << "#endif" << endl;
-
-  // Close output file
-  f_types_.close();
-  f_types_impl_.close();
-  f_types_tcc_.close();
-}
-
-/**
- * Generates a typedef. This is just a simple 1-liner in C++
- *
- * @param ttypedef The type definition
- */
-void t_cpp_generator::generate_typedef(t_typedef* ttypedef) {
-  f_types_ << indent() << "typedef " << type_name(ttypedef->get_type(), true) << " "
-           << ttypedef->get_symbolic() << ";" << endl << endl;
-}
-
-void t_cpp_generator::generate_enum_constant_list(std::ostream& f,
-                                                  const vector<t_enum_value*>& constants,
-                                                  const char* prefix,
-                                                  const char* suffix,
-                                                  bool include_values) {
-  f << " {" << endl;
-  indent_up();
-
-  vector<t_enum_value*>::const_iterator c_iter;
-  bool first = true;
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    if (first) {
-      first = false;
-    } else {
-      f << "," << endl;
-    }
-    indent(f) << prefix << (*c_iter)->get_name() << suffix;
-    if (include_values) {
-      f << " = " << (*c_iter)->get_value();
-    }
-  }
-
-  f << endl;
-  indent_down();
-  indent(f) << "};" << endl;
-}
-
-/**
- * Generates code for an enumerated type. In C++, this is essentially the same
- * as the thrift definition itself, using the enum keyword in C++.
- *
- * @param tenum The enumeration
- */
-void t_cpp_generator::generate_enum(t_enum* tenum) {
-  vector<t_enum_value*> constants = tenum->get_constants();
-
-  std::string enum_name = tenum->get_name();
-  if (!gen_pure_enums_) {
-    enum_name = "type";
-    f_types_ << indent() << "struct " << tenum->get_name() << " {" << endl;
-    indent_up();
-  }
-  f_types_ << indent() << "enum " << enum_name;
-
-  generate_enum_constant_list(f_types_, constants, "", "", true);
-
-  if (!gen_pure_enums_) {
-    indent_down();
-    f_types_ << "};" << endl;
-  }
-
-  f_types_ << endl;
-
-  /**
-     Generate a character array of enum names for debugging purposes.
-  */
-  std::string prefix = "";
-  if (!gen_pure_enums_) {
-    prefix = tenum->get_name() + "::";
-  }
-
-  f_types_impl_ << indent() << "int _k" << tenum->get_name() << "Values[] =";
-  generate_enum_constant_list(f_types_impl_, constants, prefix.c_str(), "", false);
-
-  f_types_impl_ << indent() << "const char* _k" << tenum->get_name() << "Names[] =";
-  generate_enum_constant_list(f_types_impl_, constants, "\"", "\"", false);
-
-  f_types_ << indent() << "extern const std::map<int, const char*> _" << tenum->get_name()
-           << "_VALUES_TO_NAMES;" << endl << endl;
-
-  f_types_impl_ << indent() << "const std::map<int, const char*> _" << tenum->get_name()
-                << "_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(" << constants.size() << ", _k"
-                << tenum->get_name() << "Values"
-                << ", _k" << tenum->get_name() << "Names), "
-                << "::apache::thrift::TEnumIterator(-1, NULL, NULL));" << endl << endl;
-
-  generate_enum_ostream_operator_decl(f_types_, tenum);
-  generate_enum_ostream_operator(f_types_impl_, tenum);
-}
-
-void t_cpp_generator::generate_enum_ostream_operator_decl(std::ostream& out, t_enum* tenum) {
-
-  out << "std::ostream& operator<<(std::ostream& out, const ";
-  if (gen_pure_enums_) {
-    out << tenum->get_name();
-  } else {
-    out << tenum->get_name() << "::type&";
-  }
-  out << " val);" << endl;
-  out << endl;
-}
-
-void t_cpp_generator::generate_enum_ostream_operator(std::ostream& out, t_enum* tenum) {
-
-  // If we've been told the consuming application will provide an ostream
-  // operator definition then we only make a declaration:
-
-  if (!has_custom_ostream(tenum)) {
-    out << "std::ostream& operator<<(std::ostream& out, const ";
-    if (gen_pure_enums_) {
-      out << tenum->get_name();
-    } else {
-      out << tenum->get_name() << "::type&";
-    }
-    out << " val) ";
-    scope_up(out);
-
-    out << indent() << "std::map<int, const char*>::const_iterator it = _"
-             << tenum->get_name() << "_VALUES_TO_NAMES.find(val);" << endl;
-    out << indent() << "if (it != _" << tenum->get_name() << "_VALUES_TO_NAMES.end()) {" << endl;
-    indent_up();
-    out << indent() << "out << it->second;" << endl;
-    indent_down();
-    out << indent() << "} else {" << endl;
-    indent_up();
-    out << indent() << "out << static_cast<int>(val);" << endl;
-    indent_down();
-    out << indent() << "}" << endl;
-
-    out << indent() << "return out;" << endl;
-    scope_down(out);
-    out << endl;
-  }
-}
-
-/**
- * Generates a class that holds all the constants.
- */
-void t_cpp_generator::generate_consts(std::vector<t_const*> consts) {
-  string f_consts_name = get_out_dir() + program_name_ + "_constants.h";
-  ofstream_with_content_based_conditional_update f_consts;
-  f_consts.open(f_consts_name);
-
-  string f_consts_impl_name = get_out_dir() + program_name_ + "_constants.cpp";
-  ofstream_with_content_based_conditional_update f_consts_impl;
-  f_consts_impl.open(f_consts_impl_name);
-
-  // Print header
-  f_consts << autogen_comment();
-  f_consts_impl << autogen_comment();
-
-  // Start ifndef
-  f_consts << "#ifndef " << program_name_ << "_CONSTANTS_H" << endl << "#define " << program_name_
-           << "_CONSTANTS_H" << endl << endl << "#include \"" << get_include_prefix(*get_program())
-           << program_name_ << "_types.h\"" << endl << endl << ns_open_ << endl << endl;
-
-  f_consts_impl << "#include \"" << get_include_prefix(*get_program()) << program_name_
-                << "_constants.h\"" << endl << endl << ns_open_ << endl << endl;
-
-  f_consts << "class " << program_name_ << "Constants {" << endl << " public:" << endl << "  "
-           << program_name_ << "Constants();" << endl << endl;
-  indent_up();
-  vector<t_const*>::iterator c_iter;
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    string name = (*c_iter)->get_name();
-    t_type* type = (*c_iter)->get_type();
-    f_consts << indent() << type_name(type) << " " << name << ";" << endl;
-  }
-  indent_down();
-  f_consts << "};" << endl;
-
-  f_consts_impl << "const " << program_name_ << "Constants g_" << program_name_ << "_constants;"
-                << endl << endl << program_name_ << "Constants::" << program_name_
-                << "Constants() {" << endl;
-  indent_up();
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    print_const_value(f_consts_impl,
-                      (*c_iter)->get_name(),
-                      (*c_iter)->get_type(),
-                      (*c_iter)->get_value());
-  }
-  indent_down();
-  indent(f_consts_impl) << "}" << endl;
-
-  f_consts << endl << "extern const " << program_name_ << "Constants g_" << program_name_
-           << "_constants;" << endl << endl << ns_close_ << endl << endl << "#endif" << endl;
-  f_consts.close();
-
-  f_consts_impl << endl << ns_close_ << endl << endl;
-  f_consts_impl.close();
-}
-
-/**
- * Prints the value of a constant with the given type. Note that type checking
- * is NOT performed in this function as it is always run beforehand using the
- * validate_types method in main.cc
- */
-void t_cpp_generator::print_const_value(ostream& out,
-                                        string name,
-                                        t_type* type,
-                                        t_const_value* value) {
-  type = get_true_type(type);
-  if (type->is_base_type()) {
-    string v2 = render_const_value(out, name, type, value);
-    indent(out) << name << " = " << v2 << ";" << endl << endl;
-  } else if (type->is_enum()) {
-    indent(out) << name << " = (" << type_name(type) << ")" << value->get_integer() << ";" << endl
-                << endl;
-  } else if (type->is_struct() || type->is_xception()) {
-    const vector<t_field*>& fields = ((t_struct*)type)->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    bool is_nonrequired_field = false;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      t_type* field_type = NULL;
-      is_nonrequired_field = false;
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field_type = (*f_iter)->get_type();
-          is_nonrequired_field = (*f_iter)->get_req() != t_field::T_REQUIRED;
-        }
-      }
-      if (field_type == NULL) {
-        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
-      }
-      string val = render_const_value(out, name, field_type, v_iter->second);
-      indent(out) << name << "." << v_iter->first->get_string() << " = " << val << ";" << endl;
-      if (is_nonrequired_field) {
-        indent(out) << name << ".__isset." << v_iter->first->get_string() << " = true;" << endl;
-      }
-    }
-    out << endl;
-  } else if (type->is_map()) {
-    t_type* ktype = ((t_map*)type)->get_key_type();
-    t_type* vtype = ((t_map*)type)->get_val_type();
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string key = render_const_value(out, name, ktype, v_iter->first);
-      string val = render_const_value(out, name, vtype, v_iter->second);
-      indent(out) << name << ".insert(std::make_pair(" << key << ", " << val << "));" << endl;
-    }
-    out << endl;
-  } else if (type->is_list()) {
-    t_type* etype = ((t_list*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string val = render_const_value(out, name, etype, *v_iter);
-      indent(out) << name << ".push_back(" << val << ");" << endl;
-    }
-    out << endl;
-  } else if (type->is_set()) {
-    t_type* etype = ((t_set*)type)->get_elem_type();
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string val = render_const_value(out, name, etype, *v_iter);
-      indent(out) << name << ".insert(" << val << ");" << endl;
-    }
-    out << endl;
-  } else {
-    throw "INVALID TYPE IN print_const_value: " + type->get_name();
-  }
-}
-
-/**
- *
- */
-string t_cpp_generator::render_const_value(ostream& out,
-                                           string name,
-                                           t_type* type,
-                                           t_const_value* value) {
-  (void)name;
-  std::ostringstream render;
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      render << '"' << get_escaped_string(value) << '"';
-      break;
-    case t_base_type::TYPE_BOOL:
-      render << ((value->get_integer() > 0) ? "true" : "false");
-      break;
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-      render << value->get_integer();
-      break;
-    case t_base_type::TYPE_I64:
-      render << value->get_integer() << "LL";
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      if (value->get_type() == t_const_value::CV_INTEGER) {
-        render << "static_cast<double>(" << value->get_integer() << ")";
-      } else {
-        render << emit_double_as_string(value->get_double());
-      }
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else if (type->is_enum()) {
-    render << "(" << type_name(type) << ")" << value->get_integer();
-  } else {
-    string t = tmp("tmp");
-    indent(out) << type_name(type) << " " << t << ";" << endl;
-    print_const_value(out, t, type, value);
-    render << t;
-  }
-
-  return render.str();
-}
-
-void t_cpp_generator::generate_forward_declaration(t_struct* tstruct) {
-  // Forward declare struct def
-  f_types_ << indent() << "class " << tstruct->get_name() << ";" << endl << endl;
-}
-
-/**
- * Generates a struct definition for a thrift data type. This is a class
- * with data members and a read/write() function, plus a mirroring isset
- * inner class.
- *
- * @param tstruct The struct definition
- */
-void t_cpp_generator::generate_cpp_struct(t_struct* tstruct, bool is_exception) {
-  generate_struct_declaration(f_types_, tstruct, is_exception, false, true, true, true, true);
-  generate_struct_definition(f_types_impl_, f_types_impl_, tstruct, true, true);
-
-  std::ostream& out = (gen_templates_ ? f_types_tcc_ : f_types_impl_);
-  generate_struct_reader(out, tstruct);
-  generate_struct_writer(out, tstruct);
-  generate_struct_swap(f_types_impl_, tstruct);
-  generate_copy_constructor(f_types_impl_, tstruct, is_exception);
-  if (gen_moveable_) {
-    generate_move_constructor(f_types_impl_, tstruct, is_exception);
-  }
-  generate_assignment_operator(f_types_impl_, tstruct);
-  if (gen_moveable_) {
-    generate_move_assignment_operator(f_types_impl_, tstruct);
-  }
-
-  if (!has_custom_ostream(tstruct)) {
-    generate_struct_print_method(f_types_impl_, tstruct);
-  }
-
-  if (is_exception) {
-    generate_exception_what_method(f_types_impl_, tstruct);
-  }
-}
-
-void t_cpp_generator::generate_copy_constructor(ostream& out,
-                                                t_struct* tstruct,
-                                                bool is_exception) {
-  generate_constructor_helper(out, tstruct, is_exception, /*is_move=*/false);
-}
-
-void t_cpp_generator::generate_move_constructor(ostream& out,
-                                                t_struct* tstruct,
-                                                bool is_exception) {
-  generate_constructor_helper(out, tstruct, is_exception, /*is_move=*/true);
-}
-
-namespace {
-// Helper to convert a variable to rvalue, if move is enabled
-std::string maybeMove(std::string const& other, bool move) {
-  if (move) {
-    return "std::move(" + other + ")";
-  }
-  return other;
-}
-}
-
-void t_cpp_generator::generate_constructor_helper(ostream& out,
-                                                  t_struct* tstruct,
-                                                  bool is_exception,
-                                                  bool is_move) {
-
-  std::string tmp_name = tmp("other");
-
-  indent(out) << tstruct->get_name() << "::" << tstruct->get_name();
-
-  if (is_move) {
-    out << "( " << tstruct->get_name() << "&& ";
-  } else {
-    out << "(const " << tstruct->get_name() << "& ";
-  }
-  out << tmp_name << ") ";
-  if (is_exception)
-    out << ": TException() ";
-  out << "{" << endl;
-  indent_up();
-
-  const vector<t_field*>& members = tstruct->get_members();
-
-  // eliminate compiler unused warning
-  if (members.empty())
-    indent(out) << "(void) " << tmp_name << ";" << endl;
-
-  vector<t_field*>::const_iterator f_iter;
-  bool has_nonrequired_fields = false;
-  for (f_iter = members.begin(); f_iter != members.end(); ++f_iter) {
-    if ((*f_iter)->get_req() != t_field::T_REQUIRED)
-      has_nonrequired_fields = true;
-    indent(out) << (*f_iter)->get_name() << " = "
-                << maybeMove(tmp_name + "." + (*f_iter)->get_name(), is_move) << ";" << endl;
-  }
-
-  if (has_nonrequired_fields) {
-    indent(out) << "__isset = " << maybeMove(tmp_name + ".__isset", is_move) << ";" << endl;
-  }
-
-  indent_down();
-  indent(out) << "}" << endl;
-}
-
-void t_cpp_generator::generate_assignment_operator(ostream& out, t_struct* tstruct) {
-  generate_assignment_helper(out, tstruct, /*is_move=*/false);
-}
-
-void t_cpp_generator::generate_move_assignment_operator(ostream& out, t_struct* tstruct) {
-  generate_assignment_helper(out, tstruct, /*is_move=*/true);
-}
-
-void t_cpp_generator::generate_assignment_helper(ostream& out, t_struct* tstruct, bool is_move) {
-  std::string tmp_name = tmp("other");
-
-  indent(out) << tstruct->get_name() << "& " << tstruct->get_name() << "::operator=(";
-
-  if (is_move) {
-    out << tstruct->get_name() << "&& ";
-  } else {
-    out << "const " << tstruct->get_name() << "& ";
-  }
-  out << tmp_name << ") {" << endl;
-
-  indent_up();
-
-  const vector<t_field*>& members = tstruct->get_members();
-
-  // eliminate compiler unused warning
-  if (members.empty())
-    indent(out) << "(void) " << tmp_name << ";" << endl;
-
-  vector<t_field*>::const_iterator f_iter;
-  bool has_nonrequired_fields = false;
-  for (f_iter = members.begin(); f_iter != members.end(); ++f_iter) {
-    if ((*f_iter)->get_req() != t_field::T_REQUIRED)
-      has_nonrequired_fields = true;
-    indent(out) << (*f_iter)->get_name() << " = "
-                << maybeMove(tmp_name + "." + (*f_iter)->get_name(), is_move) << ";" << endl;
-  }
-  if (has_nonrequired_fields) {
-    indent(out) << "__isset = " << maybeMove(tmp_name + ".__isset", is_move) << ";" << endl;
-  }
-
-  indent(out) << "return *this;" << endl;
-  indent_down();
-  indent(out) << "}" << endl;
-}
-
-/**
- * Writes the struct declaration into the header file
- *
- * @param out Output stream
- * @param tstruct The struct
- */
-void t_cpp_generator::generate_struct_declaration(ostream& out,
-                                                  t_struct* tstruct,
-                                                  bool is_exception,
-                                                  bool pointers,
-                                                  bool read,
-                                                  bool write,
-                                                  bool swap,
-                                                  bool is_user_struct) {
-  string extends = "";
-  if (is_exception) {
-    extends = " : public ::apache::thrift::TException";
-  } else {
-    if (is_user_struct && !gen_templates_) {
-      extends = " : public virtual ::apache::thrift::TBase";
-    }
-  }
-
-  // Get members
-  vector<t_field*>::const_iterator m_iter;
-  const vector<t_field*>& members = tstruct->get_members();
-
-  // Write the isset structure declaration outside the class. This makes
-  // the generated code amenable to processing by SWIG.
-  // We only declare the struct if it gets used in the class.
-
-  // Isset struct has boolean fields, but only for non-required fields.
-  bool has_nonrequired_fields = false;
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    if ((*m_iter)->get_req() != t_field::T_REQUIRED)
-      has_nonrequired_fields = true;
-  }
-
-  if (has_nonrequired_fields && (!pointers || read)) {
-
-    out << indent() << "typedef struct _" << tstruct->get_name() << "__isset {" << endl;
-    indent_up();
-
-    indent(out) << "_" << tstruct->get_name() << "__isset() ";
-    bool first = true;
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      if ((*m_iter)->get_req() == t_field::T_REQUIRED) {
-        continue;
-      }
-      string isSet = ((*m_iter)->get_value() != NULL) ? "true" : "false";
-      if (first) {
-        first = false;
-        out << ": " << (*m_iter)->get_name() << "(" << isSet << ")";
-      } else {
-        out << ", " << (*m_iter)->get_name() << "(" << isSet << ")";
-      }
-    }
-    out << " {}" << endl;
-
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      if ((*m_iter)->get_req() != t_field::T_REQUIRED) {
-        indent(out) << "bool " << (*m_iter)->get_name() << " :1;" << endl;
-      }
-    }
-
-    indent_down();
-    indent(out) << "} _" << tstruct->get_name() << "__isset;" << endl;
-  }
-
-  out << endl;
-
-  // Open struct def
-  out << indent() << "class " << tstruct->get_name() << extends << " {" << endl << indent()
-      << " public:" << endl << endl;
-  indent_up();
-
-  if (!pointers) {
-    // Copy constructor
-    indent(out) << tstruct->get_name() << "(const " << tstruct->get_name() << "&);" << endl;
-
-    // Move constructor
-    if (gen_moveable_) {
-      indent(out) << tstruct->get_name() << "(" << tstruct->get_name() << "&&);" << endl;
-    }
-
-    // Assignment Operator
-    indent(out) << tstruct->get_name() << "& operator=(const " << tstruct->get_name() << "&);"
-                << endl;
-
-    // Move assignment operator
-    if (gen_moveable_) {
-      indent(out) << tstruct->get_name() << "& operator=(" << tstruct->get_name() << "&&);" << endl;
-    }
-
-    // Default constructor
-    indent(out) << tstruct->get_name() << "()";
-
-    bool init_ctor = false;
-
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      t_type* t = get_true_type((*m_iter)->get_type());
-      if (t->is_base_type() || t->is_enum() || is_reference(*m_iter)) {
-        string dval;
-        if (t->is_enum()) {
-          dval += "(" + type_name(t) + ")";
-        }
-        dval += (t->is_string() || is_reference(*m_iter)) ? "" : "0";
-        t_const_value* cv = (*m_iter)->get_value();
-        if (cv != NULL) {
-          dval = render_const_value(out, (*m_iter)->get_name(), t, cv);
-        }
-        if (!init_ctor) {
-          init_ctor = true;
-          out << " : ";
-          out << (*m_iter)->get_name() << "(" << dval << ")";
-        } else {
-          out << ", " << (*m_iter)->get_name() << "(" << dval << ")";
-        }
-      }
-    }
-    out << " {" << endl;
-    indent_up();
-    // TODO(dreiss): When everything else in Thrift is perfect,
-    // do more of these in the initializer list.
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      t_type* t = get_true_type((*m_iter)->get_type());
-
-      if (!t->is_base_type()) {
-        t_const_value* cv = (*m_iter)->get_value();
-        if (cv != NULL) {
-          print_const_value(out, (*m_iter)->get_name(), t, cv);
-        }
-      }
-    }
-    scope_down(out);
-  }
-
-  if (tstruct->annotations_.find("final") == tstruct->annotations_.end()) {
-    out << endl << indent() << "virtual ~" << tstruct->get_name() << "() throw();" << endl;
-  }
-
-  // Declare all fields
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    indent(out) << declare_field(*m_iter,
-                                 false,
-                                 (pointers && !(*m_iter)->get_type()->is_xception()),
-                                 !read) << endl;
-  }
-
-  // Add the __isset data member if we need it, using the definition from above
-  if (has_nonrequired_fields && (!pointers || read)) {
-    out << endl << indent() << "_" << tstruct->get_name() << "__isset __isset;" << endl;
-  }
-
-  // Create a setter function for each field
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    if (pointers) {
-      continue;
-    }
-    if (is_reference((*m_iter))) {
-      out << endl << indent() << "void __set_" << (*m_iter)->get_name() << "(::apache::thrift::stdcxx::shared_ptr<"
-          << type_name((*m_iter)->get_type(), false, false) << ">";
-      out << " val);" << endl;
-    } else {
-      out << endl << indent() << "void __set_" << (*m_iter)->get_name() << "("
-          << type_name((*m_iter)->get_type(), false, true);
-      out << " val);" << endl;
-    }
-  }
-  out << endl;
-
-  if (!pointers) {
-    // Should we generate default operators?
-    if (!gen_no_default_operators_) {
-      // Generate an equality testing operator.  Make it inline since the compiler
-      // will do a better job than we would when deciding whether to inline it.
-      out << indent() << "bool operator == (const " << tstruct->get_name() << " & "
-          << (members.size() > 0 ? "rhs" : "/* rhs */") << ") const" << endl;
-      scope_up(out);
-      for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-        // Most existing Thrift code does not use isset or optional/required,
-        // so we treat "default" fields as required.
-        if ((*m_iter)->get_req() != t_field::T_OPTIONAL) {
-          out << indent() << "if (!(" << (*m_iter)->get_name() << " == rhs."
-              << (*m_iter)->get_name() << "))" << endl << indent() << "  return false;" << endl;
-        } else {
-          out << indent() << "if (__isset." << (*m_iter)->get_name() << " != rhs.__isset."
-              << (*m_iter)->get_name() << ")" << endl << indent() << "  return false;" << endl
-              << indent() << "else if (__isset." << (*m_iter)->get_name() << " && !("
-              << (*m_iter)->get_name() << " == rhs." << (*m_iter)->get_name() << "))" << endl
-              << indent() << "  return false;" << endl;
-        }
-      }
-      indent(out) << "return true;" << endl;
-      scope_down(out);
-      out << indent() << "bool operator != (const " << tstruct->get_name() << " &rhs) const {"
-          << endl << indent() << "  return !(*this == rhs);" << endl << indent() << "}" << endl
-          << endl;
-
-      // Generate the declaration of a less-than operator.  This must be
-      // implemented by the application developer if they wish to use it.  (They
-      // will get a link error if they try to use it without an implementation.)
-      out << indent() << "bool operator < (const " << tstruct->get_name() << " & ) const;" << endl
-          << endl;
-    }
-  }
-
-  if (read) {
-    if (gen_templates_) {
-      out << indent() << "template <class Protocol_>" << endl << indent()
-          << "uint32_t read(Protocol_* iprot);" << endl;
-    } else {
-      out << indent() << "uint32_t read("
-          << "::apache::thrift::protocol::TProtocol* iprot);" << endl;
-    }
-  }
-  if (write) {
-    if (gen_templates_) {
-      out << indent() << "template <class Protocol_>" << endl << indent()
-          << "uint32_t write(Protocol_* oprot) const;" << endl;
-    } else {
-      out << indent() << "uint32_t write("
-          << "::apache::thrift::protocol::TProtocol* oprot) const;" << endl;
-    }
-  }
-  out << endl;
-
-  if (is_user_struct && !has_custom_ostream(tstruct)) {
-    out << indent() << "virtual ";
-    generate_struct_print_method_decl(out, NULL);
-    out << ";" << endl;
-  }
-
-  // std::exception::what()
-  if (is_exception) {
-    out << indent() << "mutable std::string thriftTExceptionMessageHolder_;" << endl;
-    out << indent();
-    generate_exception_what_method_decl(out, tstruct, false);
-    out << ";" << endl;
-  }
-
-  indent_down();
-  indent(out) << "};" << endl << endl;
-
-  if (swap) {
-    // Generate a namespace-scope swap() function
-    out << indent() << "void swap(" << tstruct->get_name() << " &a, " << tstruct->get_name()
-        << " &b);" << endl << endl;
-  }
-
-  if (is_user_struct) {
-    generate_struct_ostream_operator_decl(out, tstruct);
-  }
-}
-
-void t_cpp_generator::generate_struct_definition(ostream& out,
-                                                 ostream& force_cpp_out,
-                                                 t_struct* tstruct,
-                                                 bool setters,
-                                                 bool is_user_struct) {
-  // Get members
-  vector<t_field*>::const_iterator m_iter;
-  const vector<t_field*>& members = tstruct->get_members();
-
-  // Destructor
-  if (tstruct->annotations_.find("final") == tstruct->annotations_.end()) {
-    force_cpp_out << endl << indent() << tstruct->get_name() << "::~" << tstruct->get_name()
-                  << "() throw() {" << endl;
-    indent_up();
-
-    indent_down();
-    force_cpp_out << indent() << "}" << endl << endl;
-  }
-
-  // Create a setter function for each field
-  if (setters) {
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      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<"
-            << type_name((*m_iter)->get_type(), false, false) << ">";
-        out << " val) {" << endl;
-      } else {
-        out << endl << indent() << "void " << tstruct->get_name() << "::__set_"
-            << (*m_iter)->get_name() << "(" << type_name((*m_iter)->get_type(), false, true);
-        out << " val) {" << endl;
-      }
-      indent_up();
-      out << indent() << "this->" << (*m_iter)->get_name() << " = val;" << endl;
-      indent_down();
-
-      // assume all fields are required except optional fields.
-      // for optional fields change __isset.name to true
-      bool is_optional = (*m_iter)->get_req() == t_field::T_OPTIONAL;
-      if (is_optional) {
-        out << indent() << indent() << "__isset." << (*m_iter)->get_name() << " = true;" << endl;
-      }
-      out << indent() << "}" << endl;
-    }
-  }
-  if (is_user_struct) {
-    generate_struct_ostream_operator(out, tstruct);
-  }
-  out << endl;
-}
-
-/**
- * Makes a helper function to gen a struct reader.
- *
- * @param out Stream to write to
- * @param tstruct The struct
- */
-void t_cpp_generator::generate_struct_reader(ostream& out, t_struct* tstruct, bool pointers) {
-  if (gen_templates_) {
-    out << indent() << "template <class Protocol_>" << endl << indent() << "uint32_t "
-        << tstruct->get_name() << "::read(Protocol_* iprot) {" << endl;
-  } else {
-    indent(out) << "uint32_t " << tstruct->get_name()
-                << "::read(::apache::thrift::protocol::TProtocol* iprot) {" << endl;
-  }
-  indent_up();
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  // Declare stack tmp variables
-  out << endl
-      << indent() << "::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);" << endl
-      << indent() << "uint32_t xfer = 0;" << endl
-      << indent() << "std::string fname;" << endl
-      << indent() << "::apache::thrift::protocol::TType ftype;" << endl
-      << indent() << "int16_t fid;" << endl
-      << endl
-      << indent() << "xfer += iprot->readStructBegin(fname);" << endl
-      << endl
-      << indent() << "using ::apache::thrift::protocol::TProtocolException;" << endl
-      << endl;
-
-  // Required variables aren't in __isset, so we need tmp vars to check them.
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if ((*f_iter)->get_req() == t_field::T_REQUIRED)
-      indent(out) << "bool isset_" << (*f_iter)->get_name() << " = false;" << endl;
-  }
-  out << endl;
-
-  // Loop over reading in fields
-  indent(out) << "while (true)" << endl;
-  scope_up(out);
-
-  // Read beginning field marker
-  indent(out) << "xfer += iprot->readFieldBegin(fname, ftype, fid);" << endl;
-
-  // Check for field STOP marker
-  out << indent() << "if (ftype == ::apache::thrift::protocol::T_STOP) {" << endl << indent()
-      << "  break;" << endl << indent() << "}" << endl;
-
-  if (fields.empty()) {
-    out << indent() << "xfer += iprot->skip(ftype);" << endl;
-  } else {
-    // Switch statement on the field we are reading
-    indent(out) << "switch (fid)" << endl;
-
-    scope_up(out);
-
-    // Generate deserialization code for known cases
-    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-      indent(out) << "case " << (*f_iter)->get_key() << ":" << endl;
-      indent_up();
-      indent(out) << "if (ftype == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl;
-      indent_up();
-
-      const char* isset_prefix = ((*f_iter)->get_req() != t_field::T_REQUIRED) ? "this->__isset."
-                                                                               : "isset_";
-
-#if 0
-          // This code throws an exception if the same field is encountered twice.
-          // We've decided to leave it out for performance reasons.
-          // TODO(dreiss): Generate this code and "if" it out to make it easier
-          // for people recompiling thrift to include it.
-          out <<
-            indent() << "if (" << isset_prefix << (*f_iter)->get_name() << ")" << endl <<
-            indent() << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl;
-#endif
-
-      if (pointers && !(*f_iter)->get_type()->is_xception()) {
-        generate_deserialize_field(out, *f_iter, "(*(this->", "))");
-      } else {
-        generate_deserialize_field(out, *f_iter, "this->");
-      }
-      out << indent() << isset_prefix << (*f_iter)->get_name() << " = true;" << endl;
-      indent_down();
-      out << indent() << "} else {" << endl << indent() << "  xfer += iprot->skip(ftype);" << endl
-          <<
-          // TODO(dreiss): Make this an option when thrift structs
-          // have a common base class.
-          // indent() << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl <<
-          indent() << "}" << endl << indent() << "break;" << endl;
-      indent_down();
-    }
-
-    // In the default case we skip the field
-    out << indent() << "default:" << endl << indent() << "  xfer += iprot->skip(ftype);" << endl
-        << indent() << "  break;" << endl;
-
-    scope_down(out);
-  } //!fields.empty()
-  // Read field end marker
-  indent(out) << "xfer += iprot->readFieldEnd();" << endl;
-
-  scope_down(out);
-
-  out << endl << indent() << "xfer += iprot->readStructEnd();" << endl;
-
-  // Throw if any required fields are missing.
-  // We do this after reading the struct end so that
-  // there might possibly be a chance of continuing.
-  out << endl;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if ((*f_iter)->get_req() == t_field::T_REQUIRED)
-      out << indent() << "if (!isset_" << (*f_iter)->get_name() << ')' << endl << indent()
-          << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl;
-  }
-
-  indent(out) << "return xfer;" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Generates the write function.
- *
- * @param out Stream to write to
- * @param tstruct The struct
- */
-void t_cpp_generator::generate_struct_writer(ostream& out, t_struct* tstruct, bool pointers) {
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_sorted_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  if (gen_templates_) {
-    out << indent() << "template <class Protocol_>" << endl << indent() << "uint32_t "
-        << tstruct->get_name() << "::write(Protocol_* oprot) const {" << endl;
-  } else {
-    indent(out) << "uint32_t " << tstruct->get_name()
-                << "::write(::apache::thrift::protocol::TProtocol* oprot) const {" << endl;
-  }
-  indent_up();
-
-  out << indent() << "uint32_t xfer = 0;" << endl;
-
-  indent(out) << "::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);" << endl;
-  indent(out) << "xfer += oprot->writeStructBegin(\"" << name << "\");" << endl;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    bool check_if_set = (*f_iter)->get_req() == t_field::T_OPTIONAL
-                        || (*f_iter)->get_type()->is_xception();
-    if (check_if_set) {
-      out << endl << indent() << "if (this->__isset." << (*f_iter)->get_name() << ") {" << endl;
-      indent_up();
-    } else {
-      out << endl;
-    }
-
-    // Write field header
-    out << indent() << "xfer += oprot->writeFieldBegin("
-        << "\"" << (*f_iter)->get_name() << "\", " << type_to_enum((*f_iter)->get_type()) << ", "
-        << (*f_iter)->get_key() << ");" << endl;
-    // Write field contents
-    if (pointers && !(*f_iter)->get_type()->is_xception()) {
-      generate_serialize_field(out, *f_iter, "(*(this->", "))");
-    } else {
-      generate_serialize_field(out, *f_iter, "this->");
-    }
-    // Write field closer
-    indent(out) << "xfer += oprot->writeFieldEnd();" << endl;
-    if (check_if_set) {
-      indent_down();
-      indent(out) << '}';
-    }
-  }
-
-  out << endl;
-
-  // Write the struct map
-  out << indent() << "xfer += oprot->writeFieldStop();" << endl << indent()
-      << "xfer += oprot->writeStructEnd();" << endl << indent()
-      << "return xfer;" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Struct writer for result of a function, which can have only one of its
- * fields set and does a conditional if else look up into the __isset field
- * of the struct.
- *
- * @param out Output stream
- * @param tstruct The result struct
- */
-void t_cpp_generator::generate_struct_result_writer(ostream& out,
-                                                    t_struct* tstruct,
-                                                    bool pointers) {
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_sorted_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  if (gen_templates_) {
-    out << indent() << "template <class Protocol_>" << endl << indent() << "uint32_t "
-        << tstruct->get_name() << "::write(Protocol_* oprot) const {" << endl;
-  } else {
-    indent(out) << "uint32_t " << tstruct->get_name()
-                << "::write(::apache::thrift::protocol::TProtocol* oprot) const {" << endl;
-  }
-  indent_up();
-
-  out << endl << indent() << "uint32_t xfer = 0;" << endl << endl;
-
-  indent(out) << "xfer += oprot->writeStructBegin(\"" << name << "\");" << endl;
-
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-      out << endl << indent() << "if ";
-    } else {
-      out << " else if ";
-    }
-
-    out << "(this->__isset." << (*f_iter)->get_name() << ") {" << endl;
-
-    indent_up();
-
-    // Write field header
-    out << indent() << "xfer += oprot->writeFieldBegin("
-        << "\"" << (*f_iter)->get_name() << "\", " << type_to_enum((*f_iter)->get_type()) << ", "
-        << (*f_iter)->get_key() << ");" << endl;
-    // Write field contents
-    if (pointers) {
-      generate_serialize_field(out, *f_iter, "(*(this->", "))");
-    } else {
-      generate_serialize_field(out, *f_iter, "this->");
-    }
-    // Write field closer
-    indent(out) << "xfer += oprot->writeFieldEnd();" << endl;
-
-    indent_down();
-    indent(out) << "}";
-  }
-
-  // Write the struct map
-  out << endl << indent() << "xfer += oprot->writeFieldStop();" << endl << indent()
-      << "xfer += oprot->writeStructEnd();" << endl << indent() << "return xfer;" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-/**
- * Generates the swap function.
- *
- * @param out Stream to write to
- * @param tstruct The struct
- */
-void t_cpp_generator::generate_struct_swap(ostream& out, t_struct* tstruct) {
-  out << indent() << "void swap(" << tstruct->get_name() << " &a, " << tstruct->get_name()
-      << " &b) {" << endl;
-  indent_up();
-
-  // Let argument-dependent name lookup find the correct swap() function to
-  // use based on the argument types.  If none is found in the arguments'
-  // namespaces, fall back to ::std::swap().
-  out << indent() << "using ::std::swap;" << endl;
-
-  bool has_nonrequired_fields = false;
-  const vector<t_field*>& fields = tstruct->get_members();
-  for (vector<t_field*>::const_iterator f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_field* tfield = *f_iter;
-
-    if (tfield->get_req() != t_field::T_REQUIRED) {
-      has_nonrequired_fields = true;
-    }
-
-    out << indent() << "swap(a." << tfield->get_name() << ", b." << tfield->get_name() << ");"
-        << endl;
-  }
-
-  if (has_nonrequired_fields) {
-    out << indent() << "swap(a.__isset, b.__isset);" << endl;
-  }
-
-  // handle empty structs
-  if (fields.size() == 0) {
-    out << indent() << "(void) a;" << endl;
-    out << indent() << "(void) b;" << endl;
-  }
-
-  scope_down(out);
-  out << endl;
-}
-
-void t_cpp_generator::generate_struct_ostream_operator_decl(std::ostream& out, t_struct* tstruct) {
-  out << "std::ostream& operator<<(std::ostream& out, const "
-      << tstruct->get_name()
-      << "& obj);" << endl;
-  out << endl;
-}
-
-void t_cpp_generator::generate_struct_ostream_operator(std::ostream& out, t_struct* tstruct) {
-  if (!has_custom_ostream(tstruct)) {
-    // thrift defines this behavior
-    out << "std::ostream& operator<<(std::ostream& out, const "
-        << tstruct->get_name()
-        << "& obj)" << endl;
-    scope_up(out);
-    out << indent() << "obj.printTo(out);" << endl
-        << indent() << "return out;" << endl;
-    scope_down(out);
-    out << endl;
-  }
-}
-
-void t_cpp_generator::generate_struct_print_method_decl(std::ostream& out, t_struct* tstruct) {
-  out << "void ";
-  if (tstruct) {
-    out << tstruct->get_name() << "::";
-  }
-  out << "printTo(std::ostream& out) const";
-}
-
-void t_cpp_generator::generate_exception_what_method_decl(std::ostream& out,
-                                                          t_struct* tstruct,
-                                                          bool external) {
-  out << "const char* ";
-  if (external) {
-    out << tstruct->get_name() << "::";
-  }
-  out << "what() const throw()";
-}
-
-namespace struct_ostream_operator_generator {
-void generate_required_field_value(std::ostream& out, const t_field* field) {
-  out << " << to_string(" << field->get_name() << ")";
-}
-
-void generate_optional_field_value(std::ostream& out, const t_field* field) {
-  out << "; (__isset." << field->get_name() << " ? (out";
-  generate_required_field_value(out, field);
-  out << ") : (out << \"<null>\"))";
-}
-
-void generate_field_value(std::ostream& out, const t_field* field) {
-  if (field->get_req() == t_field::T_OPTIONAL)
-    generate_optional_field_value(out, field);
-  else
-    generate_required_field_value(out, field);
-}
-
-void generate_field_name(std::ostream& out, const t_field* field) {
-  out << "\"" << field->get_name() << "=\"";
-}
-
-void generate_field(std::ostream& out, const t_field* field) {
-  generate_field_name(out, field);
-  generate_field_value(out, field);
-}
-
-void generate_fields(std::ostream& out,
-                     const vector<t_field*>& fields,
-                     const std::string& indent) {
-  const vector<t_field*>::const_iterator beg = fields.begin();
-  const vector<t_field*>::const_iterator end = fields.end();
-
-  for (vector<t_field*>::const_iterator it = beg; it != end; ++it) {
-    out << indent << "out << ";
-
-    if (it != beg) {
-      out << "\", \" << ";
-    }
-
-    generate_field(out, *it);
-    out << ";" << endl;
-  }
-}
-}
-
-/**
- * Generates operator<<
- */
-void t_cpp_generator::generate_struct_print_method(std::ostream& out, t_struct* tstruct) {
-  out << indent();
-  generate_struct_print_method_decl(out, tstruct);
-  out << " {" << endl;
-
-  indent_up();
-
-  out << indent() << "using ::apache::thrift::to_string;" << endl;
-  out << indent() << "out << \"" << tstruct->get_name() << "(\";" << endl;
-  struct_ostream_operator_generator::generate_fields(out, tstruct->get_members(), indent());
-  out << indent() << "out << \")\";" << endl;
-
-  indent_down();
-  out << "}" << endl << endl;
-}
-
-/**
- * Generates what() method for exceptions
- */
-void t_cpp_generator::generate_exception_what_method(std::ostream& out, t_struct* tstruct) {
-  out << indent();
-  generate_exception_what_method_decl(out, tstruct, true);
-  out << " {" << endl;
-
-  indent_up();
-  out << indent() << "try {" << endl;
-
-  indent_up();
-  out << indent() << "std::stringstream ss;" << endl;
-  out << indent() << "ss << \"TException - service has thrown: \" << *this;" << endl;
-  out << indent() << "this->thriftTExceptionMessageHolder_ = ss.str();" << endl;
-  out << indent() << "return this->thriftTExceptionMessageHolder_.c_str();" << endl;
-  indent_down();
-
-  out << indent() << "} catch (const std::exception&) {" << endl;
-
-  indent_up();
-  out << indent() << "return \"TException - service has thrown: " << tstruct->get_name() << "\";"
-      << endl;
-  indent_down();
-
-  out << indent() << "}" << endl;
-
-  indent_down();
-  out << "}" << endl << endl;
-}
-
-/**
- * Generates a thrift service. In C++, this comprises an entirely separate
- * header and source file. The header file defines the methods and includes
- * the data types defined in the main header file, and the implementation
- * file contains implementations of the basic printer and default interfaces.
- *
- * @param tservice The service definition
- */
-void t_cpp_generator::generate_service(t_service* tservice) {
-  string svcname = tservice->get_name();
-
-  // Make output files
-  string f_header_name = get_out_dir() + svcname + ".h";
-  f_header_.open(f_header_name.c_str());
-
-  // Print header file includes
-  f_header_ << autogen_comment();
-  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
-              << "namespace apache { namespace thrift { namespace async {" << endl
-              << "class TAsyncChannel;" << endl << "}}}" << endl;
-  }
-  f_header_ << "#include <thrift/TDispatchProcessor.h>" << endl;
-  if (gen_cob_style_) {
-    f_header_ << "#include <thrift/async/TAsyncDispatchProcessor.h>" << endl;
-  }
-  f_header_ << "#include <thrift/async/TConcurrentClientSyncInfo.h>" << endl;
-  f_header_ << "#include \"" << get_include_prefix(*get_program()) << program_name_ << "_types.h\""
-            << endl;
-
-  t_service* extends_service = tservice->get_extends();
-  if (extends_service != NULL) {
-    f_header_ << "#include \"" << get_include_prefix(*(extends_service->get_program()))
-              << extends_service->get_name() << ".h\"" << endl;
-  }
-
-  f_header_ << endl << ns_open_ << endl << endl;
-
-  f_header_ << "#ifdef _MSC_VER\n"
-               "  #pragma warning( push )\n"
-               "  #pragma warning (disable : 4250 ) //inheriting methods via dominance \n"
-               "#endif\n\n";
-
-  // Service implementation file includes
-  string f_service_name = get_out_dir() + svcname + ".cpp";
-  f_service_.open(f_service_name.c_str());
-  f_service_ << autogen_comment();
-  f_service_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\"" << endl;
-  if (gen_cob_style_) {
-    f_service_ << "#include \"thrift/async/TAsyncChannel.h\"" << endl;
-  }
-  if (gen_templates_) {
-    f_service_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".tcc\""
-               << endl;
-
-    string f_service_tcc_name = get_out_dir() + svcname + ".tcc";
-    f_service_tcc_.open(f_service_tcc_name.c_str());
-    f_service_tcc_ << autogen_comment();
-    f_service_tcc_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\""
-                   << endl;
-
-    f_service_tcc_ << "#ifndef " << svcname << "_TCC" << endl << "#define " << svcname << "_TCC"
-                   << endl << endl;
-
-    if (gen_cob_style_) {
-      f_service_tcc_ << "#include \"thrift/async/TAsyncChannel.h\"" << endl;
-    }
-  }
-
-  f_service_ << endl << ns_open_ << endl << endl;
-  f_service_tcc_ << endl << ns_open_ << endl << endl;
-
-  // Generate all the components
-  generate_service_interface(tservice, "");
-  generate_service_interface_factory(tservice, "");
-  generate_service_null(tservice, "");
-  generate_service_helpers(tservice);
-  generate_service_client(tservice, "");
-  generate_service_processor(tservice, "");
-  generate_service_multiface(tservice);
-  generate_service_client(tservice, "Concurrent");
-
-  // Generate skeleton
-  if (!gen_no_skeleton_) {
-      generate_service_skeleton(tservice);
-  }
-
-  // Generate all the cob components
-  if (gen_cob_style_) {
-    generate_service_interface(tservice, "CobCl");
-    generate_service_interface(tservice, "CobSv");
-    generate_service_interface_factory(tservice, "CobSv");
-    generate_service_null(tservice, "CobSv");
-    generate_service_client(tservice, "Cob");
-    generate_service_processor(tservice, "Cob");
-
-    if (!gen_no_skeleton_) {
-      generate_service_async_skeleton(tservice);
-    }
-
-  }
-
-  f_header_ << "#ifdef _MSC_VER\n"
-               "  #pragma warning( pop )\n"
-               "#endif\n\n";
-
-  // Close the namespace
-  f_service_ << ns_close_ << endl << endl;
-  f_service_tcc_ << ns_close_ << endl << endl;
-  f_header_ << ns_close_ << endl << endl;
-
-  // TODO(simpkins): Make this a separate option
-  if (gen_templates_) {
-    f_header_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".tcc\"" << endl
-              << "#include \"" << get_include_prefix(*get_program()) << program_name_
-              << "_types.tcc\"" << endl << endl;
-  }
-
-  f_header_ << "#endif" << endl;
-  f_service_tcc_ << "#endif" << endl;
-
-  // Close the files
-  f_service_tcc_.close();
-  f_service_.close();
-  f_header_.close();
-}
-
-/**
- * Generates helper functions for a service. Basically, this generates types
- * for all the arguments and results to functions.
- *
- * @param tservice The service to generate a header definition for
- */
-void t_cpp_generator::generate_service_helpers(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_);
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    t_struct* ts = (*f_iter)->get_arglist();
-    string name_orig = ts->get_name();
-
-    // TODO(dreiss): Why is this stuff not in generate_function_helpers?
-    ts->set_name(tservice->get_name() + "_" + (*f_iter)->get_name() + "_args");
-    generate_struct_declaration(f_header_, ts, false);
-    generate_struct_definition(out, f_service_, ts, false);
-    generate_struct_reader(out, ts);
-    generate_struct_writer(out, ts);
-    ts->set_name(tservice->get_name() + "_" + (*f_iter)->get_name() + "_pargs");
-    generate_struct_declaration(f_header_, ts, false, true, false, true);
-    generate_struct_definition(out, f_service_, ts, false);
-    generate_struct_writer(out, ts, true);
-    ts->set_name(name_orig);
-
-    generate_function_helpers(tservice, *f_iter);
-  }
-}
-
-/**
- * Generates a service interface definition.
- *
- * @param tservice The service to generate a header definition for
- */
-void t_cpp_generator::generate_service_interface(t_service* tservice, string style) {
-
-  string service_if_name = service_name_ + style + "If";
-  if (style == "CobCl") {
-    // Forward declare the client.
-    string client_name = service_name_ + "CobClient";
-    if (gen_templates_) {
-      client_name += "T";
-      service_if_name += "T";
-      indent(f_header_) << "template <class Protocol_>" << endl;
-    }
-    indent(f_header_) << "class " << client_name << ";" << endl << endl;
-  }
-
-  string extends = "";
-  if (tservice->get_extends() != NULL) {
-    extends = " : virtual public " + type_name(tservice->get_extends()) + style + "If";
-    if (style == "CobCl" && gen_templates_) {
-      // TODO(simpkins): If gen_templates_ is enabled, we currently assume all
-      // parent services were also generated with templates enabled.
-      extends += "T<Protocol_>";
-    }
-  }
-
-  if (style == "CobCl" && gen_templates_) {
-    f_header_ << "template <class Protocol_>" << endl;
-  }
-  f_header_ << "class " << service_if_name << extends << " {" << endl << " public:" << endl;
-  indent_up();
-  f_header_ << indent() << "virtual ~" << service_if_name << "() {}" << endl;
-
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    if ((*f_iter)->has_doc())
-      f_header_ << endl;
-    generate_java_doc(f_header_, *f_iter);
-    f_header_ << indent() << "virtual " << function_signature(*f_iter, style) << " = 0;" << endl;
-  }
-  indent_down();
-  f_header_ << "};" << endl << endl;
-
-  if (style == "CobCl" && gen_templates_) {
-    // generate a backwards-compatible typedef for clients that do not
-    // know about the new template-style code
-    f_header_ << "typedef " << service_if_name << "< ::apache::thrift::protocol::TProtocol> "
-              << service_name_ << style << "If;" << endl << endl;
-  }
-}
-
-/**
- * Generates a service interface factory.
- *
- * @param tservice The service to generate an interface factory for.
- */
-void t_cpp_generator::generate_service_interface_factory(t_service* tservice, string style) {
-  string service_if_name = service_name_ + style + "If";
-
-  // Figure out the name of the upper-most parent class.
-  // Getting everything to work out properly with inheritance is annoying.
-  // Here's what we're doing for now:
-  //
-  // - All handlers implement getHandler(), but subclasses use covariant return
-  //   types to return their specific service interface class type.  We have to
-  //   use raw pointers because of this; shared_ptr<> can't be used for
-  //   covariant return types.
-  //
-  // - Since we're not using shared_ptr<>, we also provide a releaseHandler()
-  //   function that must be called to release a pointer to a handler obtained
-  //   via getHandler().
-  //
-  //   releaseHandler() always accepts a pointer to the upper-most parent class
-  //   type.  This is necessary since the parent versions of releaseHandler()
-  //   may accept any of the parent types, not just the most specific subclass
-  //   type.  Implementations can use dynamic_cast to cast the pointer to the
-  //   subclass type if desired.
-  t_service* base_service = tservice;
-  while (base_service->get_extends() != NULL) {
-    base_service = base_service->get_extends();
-  }
-  string base_if_name = type_name(base_service) + style + "If";
-
-  // Generate the abstract factory class
-  string factory_name = service_if_name + "Factory";
-  string extends;
-  if (tservice->get_extends() != NULL) {
-    extends = " : virtual public " + type_name(tservice->get_extends()) + style + "IfFactory";
-  }
-
-  f_header_ << "class " << factory_name << extends << " {" << endl << " public:" << endl;
-  indent_up();
-  f_header_ << indent() << "typedef " << service_if_name << " Handler;" << endl << endl << indent()
-            << "virtual ~" << factory_name << "() {}" << endl << endl << indent() << "virtual "
-            << service_if_name << "* getHandler("
-            << "const ::apache::thrift::TConnectionInfo& connInfo) = 0;" << endl << indent()
-            << "virtual void releaseHandler(" << base_if_name << "* /* handler */) = 0;" << endl;
-
-  indent_down();
-  f_header_ << "};" << endl << endl;
-
-  // Generate the singleton factory class
-  string singleton_factory_name = service_if_name + "SingletonFactory";
-  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
-            << ">& iface) : iface_(iface) {}" << endl << indent() << "virtual ~"
-            << singleton_factory_name << "() {}" << endl << endl << indent() << "virtual "
-            << service_if_name << "* getHandler("
-            << "const ::apache::thrift::TConnectionInfo&) {" << endl << indent()
-            << "  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
-            << "> iface_;" << endl;
-
-  indent_down();
-  f_header_ << "};" << endl << endl;
-}
-
-/**
- * Generates a null implementation of the service.
- *
- * @param tservice The service to generate a header definition for
- */
-void t_cpp_generator::generate_service_null(t_service* tservice, string style) {
-  string extends = "";
-  if (tservice->get_extends() != NULL) {
-    extends = " , virtual public " + type_name(tservice->get_extends()) + style + "Null";
-  }
-  f_header_ << "class " << service_name_ << style << "Null : virtual public " << service_name_
-            << style << "If" << extends << " {" << endl << " public:" << endl;
-  indent_up();
-  f_header_ << indent() << "virtual ~" << service_name_ << style << "Null() {}" << endl;
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    f_header_ << indent() << function_signature(*f_iter, style, "", false) << " {" << endl;
-    indent_up();
-
-    t_type* returntype = (*f_iter)->get_returntype();
-    t_field returnfield(returntype, "_return");
-
-    if (style == "") {
-      if (returntype->is_void() || is_complex_type(returntype)) {
-        f_header_ << indent() << "return;" << endl;
-      } else {
-        f_header_ << indent() << declare_field(&returnfield, true) << endl << indent()
-                  << "return _return;" << endl;
-      }
-    } else if (style == "CobSv") {
-      if (returntype->is_void()) {
-        f_header_ << indent() << "return cob();" << endl;
-      } else {
-        t_field returnfield(returntype, "_return");
-        f_header_ << indent() << declare_field(&returnfield, true) << endl << indent()
-                  << "return cob(_return);" << endl;
-      }
-
-    } else {
-      throw "UNKNOWN STYLE";
-    }
-
-    indent_down();
-    f_header_ << indent() << "}" << endl;
-  }
-  indent_down();
-  f_header_ << "};" << endl << endl;
-}
-
-void t_cpp_generator::generate_function_call(ostream& out,
-                                             t_function* tfunction,
-                                             string target,
-                                             string iface,
-                                             string arg_prefix) {
-  bool first = true;
-  t_type* ret_type = get_true_type(tfunction->get_returntype());
-  out << indent();
-  if (!tfunction->is_oneway() && !ret_type->is_void()) {
-    if (is_complex_type(ret_type)) {
-      first = false;
-      out << iface << "->" << tfunction->get_name() << "(" << target;
-    } else {
-      out << target << " = " << iface << "->" << tfunction->get_name() << "(";
-    }
-  } else {
-    out << iface << "->" << tfunction->get_name() << "(";
-  }
-  const std::vector<t_field*>& fields = tfunction->get_arglist()->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      out << ", ";
-    }
-    out << arg_prefix << (*f_iter)->get_name();
-  }
-  out << ");" << endl;
-}
-
-void t_cpp_generator::generate_service_async_skeleton(t_service* tservice) {
-  string svcname = tservice->get_name();
-
-  // Service implementation file includes
-  string f_skeleton_name = get_out_dir() + svcname + "_async_server.skeleton.cpp";
-
-  string ns = namespace_prefix(tservice->get_program()->get_namespace("cpp"));
-
-  ofstream_with_content_based_conditional_update f_skeleton;
-  f_skeleton.open(f_skeleton_name.c_str());
-  f_skeleton << "// This autogenerated skeleton file illustrates one way to adapt a synchronous"
-             << endl << "// interface into an asynchronous interface. You should copy it to another"
-             << endl
-             << "// filename to avoid overwriting it and rewrite as asynchronous any functions"
-             << endl << "// that would otherwise introduce unwanted latency." << endl << endl
-             << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\"" << endl
-             << "#include <thrift/protocol/TBinaryProtocol.h>" << endl << endl
-             << "using namespace ::apache::thrift;" << endl
-             << "using namespace ::apache::thrift::protocol;" << endl
-             << "using namespace ::apache::thrift::transport;" << endl
-             << "using namespace ::apache::thrift::async;" << endl << endl;
-
-  // the following code would not compile:
-  // using namespace ;
-  // using namespace ::;
-  if ((!ns.empty()) && (ns.compare(" ::") != 0)) {
-    f_skeleton << "using namespace " << string(ns, 0, ns.size() - 2) << ";" << endl << endl;
-  }
-
-  f_skeleton << "class " << svcname << "AsyncHandler : "
-             << "public " << svcname << "CobSvIf {" << endl << " public:" << endl;
-  indent_up();
-  f_skeleton << indent() << svcname << "AsyncHandler() {" << endl << indent()
-             << "  syncHandler_ = std::auto_ptr<" << svcname << "Handler>(new " << svcname
-             << "Handler);" << endl << indent() << "  // Your initialization goes here" << endl
-             << indent() << "}" << endl;
-  f_skeleton << indent() << "virtual ~" << service_name_ << "AsyncHandler();" << endl;
-
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    f_skeleton << endl << indent() << function_signature(*f_iter, "CobSv", "", true) << " {"
-               << endl;
-    indent_up();
-
-    t_type* returntype = (*f_iter)->get_returntype();
-    t_field returnfield(returntype, "_return");
-
-    string target = returntype->is_void() ? "" : "_return";
-    if (!returntype->is_void()) {
-      f_skeleton << indent() << declare_field(&returnfield, true) << endl;
-    }
-    generate_function_call(f_skeleton, *f_iter, target, "syncHandler_", "");
-    f_skeleton << indent() << "return cob(" << target << ");" << endl;
-
-    scope_down(f_skeleton);
-  }
-  f_skeleton << endl << " protected:" << endl << indent() << "std::auto_ptr<" << svcname
-             << "Handler> syncHandler_;" << endl;
-  indent_down();
-  f_skeleton << "};" << endl << endl;
-}
-
-/**
- * Generates a multiface, which is a single server that just takes a set
- * of objects implementing the interface and calls them all, returning the
- * value of the last one to be called.
- *
- * @param tservice The service to generate a multiserver for.
- */
-void t_cpp_generator::generate_service_multiface(t_service* tservice) {
-  // Generate the dispatch methods
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-
-  string extends = "";
-  string extends_multiface = "";
-  if (tservice->get_extends() != NULL) {
-    extends = type_name(tservice->get_extends());
-    extends_multiface = ", public " + extends + "Multiface";
-  }
-
-  string list_type = string("std::vector<apache::thrift::stdcxx::shared_ptr<") + service_name_ + "If> >";
-
-  // Generate the header portion
-  f_header_ << "class " << service_name_ << "Multiface : "
-            << "virtual public " << service_name_ << "If" << extends_multiface << " {" << endl
-            << " public:" << endl;
-  indent_up();
-  f_header_ << indent() << service_name_ << "Multiface(" << list_type
-            << "& ifaces) : ifaces_(ifaces) {" << endl;
-  if (!extends.empty()) {
-    f_header_ << indent()
-              << "  std::vector<apache::thrift::stdcxx::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;
-  }
-  f_header_ << indent() << "}" << endl << indent() << "virtual ~" << service_name_
-            << "Multiface() {}" << endl;
-  indent_down();
-
-  // Protected data members
-  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<"
-            << service_name_ << "If> iface) {" << endl;
-  if (!extends.empty()) {
-    f_header_ << indent() << "  " << extends << "Multiface::add(iface);" << endl;
-  }
-  f_header_ << indent() << "  ifaces_.push_back(iface);" << endl << indent() << "}" << endl;
-  indent_down();
-
-  f_header_ << indent() << " public:" << endl;
-  indent_up();
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    t_struct* arglist = (*f_iter)->get_arglist();
-    const vector<t_field*>& args = arglist->get_members();
-    vector<t_field*>::const_iterator a_iter;
-
-    string call = string("ifaces_[i]->") + (*f_iter)->get_name() + "(";
-    bool first = true;
-    if (is_complex_type((*f_iter)->get_returntype())) {
-      call += "_return";
-      first = false;
-    }
-    for (a_iter = args.begin(); a_iter != args.end(); ++a_iter) {
-      if (first) {
-        first = false;
-      } else {
-        call += ", ";
-      }
-      call += (*a_iter)->get_name();
-    }
-    call += ")";
-
-    f_header_ << indent() << function_signature(*f_iter, "") << " {" << endl;
-    indent_up();
-    f_header_ << indent() << "size_t sz = ifaces_.size();" << endl << indent() << "size_t i = 0;"
-              << endl << indent() << "for (; i < (sz - 1); ++i) {" << endl;
-    indent_up();
-    f_header_ << indent() << call << ";" << endl;
-    indent_down();
-    f_header_ << indent() << "}" << endl;
-
-    if (!(*f_iter)->get_returntype()->is_void()) {
-      if (is_complex_type((*f_iter)->get_returntype())) {
-        f_header_ << indent() << call << ";" << endl << indent() << "return;" << endl;
-      } else {
-        f_header_ << indent() << "return " << call << ";" << endl;
-      }
-    } else {
-      f_header_ << indent() << call << ";" << endl;
-    }
-
-    indent_down();
-    f_header_ << indent() << "}" << endl << endl;
-  }
-
-  indent_down();
-  f_header_ << indent() << "};" << endl << endl;
-}
-
-/**
- * Generates a service client definition.
- *
- * @param tservice The service to generate a server for.
- */
-void t_cpp_generator::generate_service_client(t_service* tservice, string style) {
-  string ifstyle;
-  if (style == "Cob") {
-    ifstyle = "CobCl";
-  }
-
-  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_);
-  string template_header, template_suffix, short_suffix, protocol_type, _this;
-  string const prot_factory_type = "::apache::thrift::protocol::TProtocolFactory";
-  if (gen_templates_) {
-    template_header = "template <class Protocol_>\n";
-    short_suffix = "T";
-    template_suffix = "T<Protocol_>";
-    protocol_type = "Protocol_";
-    _this = "this->";
-  } else {
-    protocol_type = "::apache::thrift::protocol::TProtocol";
-  }
-  string prot_ptr = "apache::thrift::stdcxx::shared_ptr< " + protocol_type + ">";
-  string client_suffix = "Client" + template_suffix;
-  string if_suffix = "If";
-  if (style == "Cob") {
-    if_suffix += template_suffix;
-  }
-
-  string extends = "";
-  string extends_client = "";
-  if (tservice->get_extends() != NULL) {
-    // TODO(simpkins): If gen_templates_ is enabled, we currently assume all
-    // parent services were also generated with templates enabled.
-    extends = type_name(tservice->get_extends());
-    extends_client = ", public " + extends + style + client_suffix;
-  }
-
-  // Generate the header portion
-  if (style == "Concurrent") {
-    f_header_ << "// The \'concurrent\' client is a thread safe client that correctly handles\n"
-                 "// out of order responses.  It is slower than the regular client, so should\n"
-                 "// only be used when you need to share a connection among multiple threads\n";
-  }
-  f_header_ << template_header << "class " << service_name_ << style << "Client" << short_suffix
-            << " : "
-            << "virtual public " << service_name_ << ifstyle << if_suffix << extends_client << " {"
-            << endl << " public:" << endl;
-
-  indent_up();
-  if (style != "Cob") {
-    f_header_ << indent() << service_name_ << style << "Client" << short_suffix << "(" << prot_ptr
-              << " prot) ";
-
-    if (extends.empty()) {
-      f_header_ << "{" << endl;
-      f_header_ << indent() << "  setProtocol" << short_suffix << "(prot);" << endl << indent()
-                << "}" << endl;
-    } else {
-      f_header_ << ":" << endl;
-      f_header_ << indent() << "  " << extends << style << client_suffix << "(prot, prot) {}"
-                << endl;
-    }
-
-    f_header_ << indent() << service_name_ << style << "Client" << short_suffix << "(" << prot_ptr
-              << " iprot, " << prot_ptr << " oprot) ";
-    if (extends.empty()) {
-      f_header_ << "{" << endl;
-      f_header_ << indent() << "  setProtocol" << short_suffix << "(iprot,oprot);" << endl
-                << indent() << "}" << endl;
-    } else {
-      f_header_ << ":" << indent() << "  " << extends << style << client_suffix
-                << "(iprot, oprot) {}" << endl;
-    }
-
-    // create the setProtocol methods
-    if (extends.empty()) {
-      f_header_ << " private:" << endl;
-      // 1: one parameter
-      f_header_ << indent() << "void setProtocol" << short_suffix << "(" << prot_ptr << " prot) {"
-                << endl;
-      f_header_ << indent() << "setProtocol" << short_suffix << "(prot,prot);" << endl;
-      f_header_ << indent() << "}" << endl;
-      // 2: two parameter
-      f_header_ << indent() << "void setProtocol" << short_suffix << "(" << prot_ptr << " iprot, "
-                << prot_ptr << " oprot) {" << endl;
-
-      f_header_ << indent() << "  piprot_=iprot;" << endl << indent() << "  poprot_=oprot;" << endl
-                << indent() << "  iprot_ = iprot.get();" << endl << indent()
-                << "  oprot_ = oprot.get();" << endl;
-
-      f_header_ << indent() << "}" << endl;
-      f_header_ << " public:" << endl;
-    }
-
-    // Generate getters for the protocols.
-    // 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() {"
-              << endl << indent() << "  return " << _this << "piprot_;" << endl << indent() << "}"
-              << endl;
-
-    f_header_ << indent()
-              << "apache::thrift::stdcxx::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, "
-              << "::apache::thrift::protocol::TProtocolFactory* protocolFactory) :" << endl;
-    if (extends.empty()) {
-      f_header_ << indent() << "  channel_(channel)," << endl << indent()
-                << "  itrans_(new ::apache::thrift::transport::TMemoryBuffer())," << endl
-                << indent() << "  otrans_(new ::apache::thrift::transport::TMemoryBuffer()),"
-                << endl;
-      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_>("
-                  << "protocolFactory->getProtocol(itrans_)))," << endl << indent()
-                  << "  poprot_(::apache::thrift::stdcxx::dynamic_pointer_cast<Protocol_>("
-                  << "protocolFactory->getProtocol(otrans_))) {" << endl;
-        // Throw a TException if either dynamic cast failed.
-        f_header_ << indent() << "  if (!piprot_ || !poprot_) {" << endl << indent()
-                  << "    throw ::apache::thrift::TException(\""
-                  << "TProtocolFactory returned unexpected protocol type in " << service_name_
-                  << style << "Client" << short_suffix << " constructor\");" << endl << indent()
-                  << "  }" << endl;
-      } else {
-        f_header_ << indent() << "  piprot_(protocolFactory->getProtocol(itrans_))," << endl
-                  << indent() << "  poprot_(protocolFactory->getProtocol(otrans_)) {" << endl;
-      }
-      f_header_ << indent() << "  iprot_ = piprot_.get();" << endl << indent()
-                << "  oprot_ = poprot_.get();" << endl << indent() << "}" << endl;
-    } else {
-      f_header_ << indent() << "  " << extends << style << client_suffix
-                << "(channel, protocolFactory) {}" << endl;
-    }
-  }
-
-  if (style == "Cob") {
-    f_header_ << indent()
-              << "::apache::thrift::stdcxx::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;
-    }
-  }
-
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    indent(f_header_) << function_signature(*f_iter, ifstyle) << ";" << endl;
-    // TODO(dreiss): Use private inheritance to avoid generating thise in cob-style.
-    if (style == "Concurrent" && !(*f_iter)->is_oneway()) {
-      // concurrent clients need to move the seqid from the send function to the
-      // recv function.  Oneway methods don't have a recv function, so we don't need to
-      // move the seqid for them.  Attempting to do so would result in a seqid leak.
-      t_function send_function(g_type_i32, /*returning seqid*/
-                               string("send_") + (*f_iter)->get_name(),
-                               (*f_iter)->get_arglist());
-      indent(f_header_) << function_signature(&send_function, "") << ";" << endl;
-    } else {
-      t_function send_function(g_type_void,
-                               string("send_") + (*f_iter)->get_name(),
-                               (*f_iter)->get_arglist());
-      indent(f_header_) << function_signature(&send_function, "") << ";" << endl;
-    }
-    if (!(*f_iter)->is_oneway()) {
-      if (style == "Concurrent") {
-        t_field seqIdArg(g_type_i32, "seqid");
-        t_struct seqIdArgStruct(program_);
-        seqIdArgStruct.append(&seqIdArg);
-        t_function recv_function((*f_iter)->get_returntype(),
-                                 string("recv_") + (*f_iter)->get_name(),
-                                 &seqIdArgStruct);
-        indent(f_header_) << function_signature(&recv_function, "") << ";" << endl;
-      } else {
-        t_struct noargs(program_);
-        t_function recv_function((*f_iter)->get_returntype(),
-                                 string("recv_") + (*f_iter)->get_name(),
-                                 &noargs);
-        indent(f_header_) << function_signature(&recv_function, "") << ";" << endl;
-      }
-    }
-  }
-  indent_down();
-
-  if (extends.empty()) {
-    f_header_ << " protected:" << endl;
-    indent_up();
-
-    if (style == "Cob") {
-      f_header_ << indent()
-                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel_;" << endl
-                << indent()
-                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> itrans_;" << endl
-                << indent()
-                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> otrans_;"
-                << endl;
-    }
-    f_header_ <<
-      indent() << prot_ptr << " piprot_;" << endl <<
-      indent() << prot_ptr << " poprot_;" << endl <<
-      indent() << protocol_type << "* iprot_;" << endl <<
-      indent() << protocol_type << "* oprot_;" << endl;
-
-    if (style == "Concurrent") {
-      f_header_ <<
-        indent() << "::apache::thrift::async::TConcurrentClientSyncInfo sync_;"<<endl;
-    }
-    indent_down();
-  }
-
-  f_header_ << "};" << endl << endl;
-
-  if (gen_templates_) {
-    // Output a backwards compatibility typedef using
-    // TProtocol as the template parameter.
-    f_header_ << "typedef " << service_name_ << style
-              << "ClientT< ::apache::thrift::protocol::TProtocol> " << service_name_ << style
-              << "Client;" << endl << endl;
-  }
-
-  string scope = service_name_ + style + client_suffix + "::";
-
-  // Generate client method implementations
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    string seqIdCapture;
-    string seqIdUse;
-    string seqIdCommaUse;
-    if (style == "Concurrent" && !(*f_iter)->is_oneway()) {
-      seqIdCapture = "int32_t seqid = ";
-      seqIdUse = "seqid";
-      seqIdCommaUse = ", seqid";
-    }
-
-    string funname = (*f_iter)->get_name();
-
-    // Open function
-    if (gen_templates_) {
-      indent(out) << template_header;
-    }
-    indent(out) << function_signature(*f_iter, ifstyle, scope) << endl;
-    scope_up(out);
-    indent(out) << seqIdCapture << "send_" << funname << "(";
-
-    // Get the struct of function call params
-    t_struct* arg_struct = (*f_iter)->get_arglist();
-
-    // Declare the function arguments
-    const vector<t_field*>& fields = arg_struct->get_members();
-    vector<t_field*>::const_iterator fld_iter;
-    bool first = true;
-    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-      if (first) {
-        first = false;
-      } else {
-        out << ", ";
-      }
-      out << (*fld_iter)->get_name();
-    }
-    out << ");" << endl;
-
-    if (style != "Cob") {
-      if (!(*f_iter)->is_oneway()) {
-        out << indent();
-        if (!(*f_iter)->get_returntype()->is_void()) {
-          if (is_complex_type((*f_iter)->get_returntype())) {
-            out << "recv_" << funname << "(_return" << seqIdCommaUse << ");" << endl;
-          } else {
-            out << "return recv_" << funname << "(" << seqIdUse << ");" << endl;
-          }
-        } else {
-          out << "recv_" << funname << "(" << seqIdUse << ");" << endl;
-        }
-      }
-    } else {
-      if (!(*f_iter)->is_oneway()) {
-        out << indent() << _this << "channel_->sendAndRecvMessage("
-            << "::apache::thrift::stdcxx::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;
-      }
-    }
-    scope_down(out);
-    out << endl;
-
-    // if (style != "Cob") // TODO(dreiss): Libify the client and don't generate this for cob-style
-    if (true) {
-      t_type* send_func_return_type = g_type_void;
-      if (style == "Concurrent" && !(*f_iter)->is_oneway()) {
-        send_func_return_type = g_type_i32;
-      }
-      // Function for sending
-      t_function send_function(send_func_return_type,
-                               string("send_") + (*f_iter)->get_name(),
-                               (*f_iter)->get_arglist());
-
-      // Open the send function
-      if (gen_templates_) {
-        indent(out) << template_header;
-      }
-      indent(out) << function_signature(&send_function, "", scope) << endl;
-      scope_up(out);
-
-      // Function arguments and results
-      string argsname = tservice->get_name() + "_" + (*f_iter)->get_name() + "_pargs";
-      string resultname = tservice->get_name() + "_" + (*f_iter)->get_name() + "_presult";
-
-      string cseqidVal = "0";
-      if (style == "Concurrent") {
-        if (!(*f_iter)->is_oneway()) {
-          cseqidVal = "this->sync_.generateSeqId()";
-        }
-      }
-      // Serialize the request
-      out <<
-        indent() << "int32_t cseqid = " << cseqidVal << ";" << endl;
-      if(style == "Concurrent") {
-        out <<
-          indent() << "::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);" << endl;
-      }
-      if (style == "Cob") {
-        out <<
-          indent() << _this << "otrans_->resetBuffer();" << endl;
-      }
-      out <<
-        indent() << _this << "oprot_->writeMessageBegin(\"" <<
-        (*f_iter)->get_name() <<
-        "\", ::apache::thrift::protocol::" << ((*f_iter)->is_oneway() ? "T_ONEWAY" : "T_CALL") <<
-        ", cseqid);" << endl << endl <<
-        indent() << argsname << " args;" << endl;
-
-      for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-        out << indent() << "args." << (*fld_iter)->get_name() << " = &" << (*fld_iter)->get_name()
-            << ";" << endl;
-      }
-
-      out << indent() << "args.write(" << _this << "oprot_);" << endl << endl << indent() << _this
-          << "oprot_->writeMessageEnd();" << endl << indent() << _this
-          << "oprot_->getTransport()->writeEnd();" << endl << indent() << _this
-          << "oprot_->getTransport()->flush();" << endl;
-
-      if (style == "Concurrent") {
-        out << endl << indent() << "sentry.commit();" << endl;
-
-        if (!(*f_iter)->is_oneway()) {
-          out << indent() << "return cseqid;" << endl;
-        }
-      }
-      scope_down(out);
-      out << endl;
-
-      // Generate recv function only if not an oneway function
-      if (!(*f_iter)->is_oneway()) {
-        t_struct noargs(program_);
-
-        t_field seqIdArg(g_type_i32, "seqid");
-        t_struct seqIdArgStruct(program_);
-        seqIdArgStruct.append(&seqIdArg);
-
-        t_struct* recv_function_args = &noargs;
-        if (style == "Concurrent") {
-          recv_function_args = &seqIdArgStruct;
-        }
-
-        t_function recv_function((*f_iter)->get_returntype(),
-                                 string("recv_") + (*f_iter)->get_name(),
-                                 recv_function_args);
-        // Open the recv function
-        if (gen_templates_) {
-          indent(out) << template_header;
-        }
-        indent(out) << function_signature(&recv_function, "", scope) << endl;
-        scope_up(out);
-
-        out << endl <<
-          indent() << "int32_t rseqid = 0;" << endl <<
-          indent() << "std::string fname;" << endl <<
-          indent() << "::apache::thrift::protocol::TMessageType mtype;" << endl;
-        if(style == "Concurrent") {
-          out <<
-            endl <<
-            indent() << "// the read mutex gets dropped and reacquired as part of waitForWork()" << endl <<
-            indent() << "// The destructor of this sentry wakes up other clients" << endl <<
-            indent() << "::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid);" << endl;
-        }
-        if (style == "Cob" && !gen_no_client_completion_) {
-          out << indent() << "bool completed = false;" << endl << endl << indent() << "try {";
-          indent_up();
-        }
-        out << endl;
-        if (style == "Concurrent") {
-          out <<
-            indent() << "while(true) {" << endl <<
-            indent() << "  if(!this->sync_.getPending(fname, mtype, rseqid)) {" << endl;
-          indent_up();
-          indent_up();
-        }
-        out <<
-          indent() << _this << "iprot_->readMessageBegin(fname, mtype, rseqid);" << endl;
-        if (style == "Concurrent") {
-          scope_down(out);
-          out << indent() << "if(seqid == rseqid) {" << endl;
-          indent_up();
-        }
-        out <<
-          indent() << "if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {" << endl <<
-          indent() << "  ::apache::thrift::TApplicationException x;" << endl <<
-          indent() << "  x.read(" << _this << "iprot_);" << endl <<
-          indent() << "  " << _this << "iprot_->readMessageEnd();" << endl <<
-          indent() << "  " << _this << "iprot_->getTransport()->readEnd();" << endl;
-        if (style == "Cob" && !gen_no_client_completion_) {
-          out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);"
-              << endl;
-        }
-        if (style == "Concurrent") {
-          out << indent() << "  sentry.commit();" << endl;
-        }
-        out <<
-          indent() << "  throw x;" << endl <<
-          indent() << "}" << endl <<
-          indent() << "if (mtype != ::apache::thrift::protocol::T_REPLY) {" << endl <<
-          indent() << "  " << _this << "iprot_->skip(" << "::apache::thrift::protocol::T_STRUCT);" << endl <<
-          indent() << "  " << _this << "iprot_->readMessageEnd();" << endl <<
-          indent() << "  " << _this << "iprot_->getTransport()->readEnd();" << endl;
-        if (style == "Cob" && !gen_no_client_completion_) {
-          out << indent() << "  completed = true;" << endl << indent() << "  completed__(false);"
-              << endl;
-        }
-        out <<
-          indent() << "}" << endl <<
-          indent() << "if (fname.compare(\"" << (*f_iter)->get_name() << "\") != 0) {" << endl <<
-          indent() << "  " << _this << "iprot_->skip(" << "::apache::thrift::protocol::T_STRUCT);" << endl <<
-          indent() << "  " << _this << "iprot_->readMessageEnd();" << endl <<
-          indent() << "  " << _this << "iprot_->getTransport()->readEnd();" << endl;
-        if (style == "Cob" && !gen_no_client_completion_) {
-          out << indent() << "  completed = true;" << endl << indent() << "  completed__(false);"
-              << endl;
-        }
-        if (style == "Concurrent") {
-          out << endl <<
-            indent() << "  // in a bad state, don't commit" << endl <<
-            indent() << "  using ::apache::thrift::protocol::TProtocolException;" << endl <<
-            indent() << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl;
-        }
-        out << indent() << "}" << endl;
-
-        if (!(*f_iter)->get_returntype()->is_void()
-            && !is_complex_type((*f_iter)->get_returntype())) {
-          t_field returnfield((*f_iter)->get_returntype(), "_return");
-          out << indent() << declare_field(&returnfield) << endl;
-        }
-
-        out << indent() << resultname << " result;" << endl;
-
-        if (!(*f_iter)->get_returntype()->is_void()) {
-          out << indent() << "result.success = &_return;" << endl;
-        }
-
-        out << indent() << "result.read(" << _this << "iprot_);" << endl << indent() << _this
-            << "iprot_->readMessageEnd();" << endl << indent() << _this
-            << "iprot_->getTransport()->readEnd();" << endl << endl;
-
-        // Careful, only look for _result if not a void function
-        if (!(*f_iter)->get_returntype()->is_void()) {
-          if (is_complex_type((*f_iter)->get_returntype())) {
-            out <<
-              indent() << "if (result.__isset.success) {" << endl;
-            out <<
-              indent() << "  // _return pointer has now been filled" << endl;
-            if (style == "Cob" && !gen_no_client_completion_) {
-              out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);"
-                  << endl;
-            }
-            if (style == "Concurrent") {
-              out << indent() << "  sentry.commit();" << endl;
-            }
-            out <<
-              indent() << "  return;" << endl <<
-              indent() << "}" << endl;
-          } else {
-            out << indent() << "if (result.__isset.success) {" << endl;
-            if (style == "Cob" && !gen_no_client_completion_) {
-              out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);"
-                  << endl;
-            }
-            if (style == "Concurrent") {
-              out << indent() << "  sentry.commit();" << endl;
-            }
-            out << indent() << "  return _return;" << endl << indent() << "}" << endl;
-          }
-        }
-
-        t_struct* xs = (*f_iter)->get_xceptions();
-        const std::vector<t_field*>& xceptions = xs->get_members();
-        vector<t_field*>::const_iterator x_iter;
-        for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-          out << indent() << "if (result.__isset." << (*x_iter)->get_name() << ") {" << endl;
-          if (style == "Cob" && !gen_no_client_completion_) {
-            out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);"
-                << endl;
-          }
-          if (style == "Concurrent") {
-            out << indent() << "  sentry.commit();" << endl;
-          }
-          out << indent() << "  throw result." << (*x_iter)->get_name() << ";" << endl << indent()
-              << "}" << endl;
-        }
-
-        // We only get here if we are a void function
-        if ((*f_iter)->get_returntype()->is_void()) {
-          if (style == "Cob" && !gen_no_client_completion_) {
-            out << indent() << "completed = true;" << endl << indent() << "completed__(true);"
-                << endl;
-          }
-          if (style == "Concurrent") {
-            out << indent() << "sentry.commit();" << endl;
-          }
-          indent(out) << "return;" << endl;
-        } else {
-          if (style == "Cob" && !gen_no_client_completion_) {
-            out << indent() << "completed = true;" << endl << indent() << "completed__(true);"
-                << endl;
-          }
-          if (style == "Concurrent") {
-            out << indent() << "// in a bad state, don't commit" << endl;
-          }
-          out << indent() << "throw "
-                             "::apache::thrift::TApplicationException(::apache::thrift::"
-                             "TApplicationException::MISSING_RESULT, \"" << (*f_iter)->get_name()
-              << " failed: unknown result\");" << endl;
-        }
-        if (style == "Concurrent") {
-          indent_down();
-          indent_down();
-          out <<
-            indent() << "  }" << endl <<
-            indent() << "  // seqid != rseqid" << endl <<
-            indent() << "  this->sync_.updatePending(fname, mtype, rseqid);" << endl <<
-            endl <<
-            indent() << "  // this will temporarily unlock the readMutex, and let other clients get work done" << endl <<
-            indent() << "  this->sync_.waitForWork(seqid);" << endl <<
-            indent() << "} // end while(true)" << endl;
-        }
-        if (style == "Cob" && !gen_no_client_completion_) {
-          indent_down();
-          out << indent() << "} catch (...) {" << endl << indent() << "  if (!completed) {" << endl
-              << indent() << "    completed__(false);" << endl << indent() << "  }" << endl
-              << indent() << "  throw;" << endl << indent() << "}" << endl;
-        }
-        // Close function
-        scope_down(out);
-        out << endl;
-      }
-    }
-  }
-}
-
-class ProcessorGenerator {
-public:
-  ProcessorGenerator(t_cpp_generator* generator, t_service* service, const string& style);
-
-  void run() {
-    generate_class_definition();
-
-    // Generate the dispatchCall() function
-    generate_dispatch_call(false);
-    if (generator_->gen_templates_) {
-      generate_dispatch_call(true);
-    }
-
-    // Generate all of the process subfunctions
-    generate_process_functions();
-
-    generate_factory();
-  }
-
-  void generate_class_definition();
-  void generate_dispatch_call(bool template_protocol);
-  void generate_process_functions();
-  void generate_factory();
-
-protected:
-  std::string type_name(t_type* ttype, bool in_typedef = false, bool arg = false) {
-    return generator_->type_name(ttype, in_typedef, arg);
-  }
-
-  std::string indent() { return generator_->indent(); }
-  std::ostream& indent(std::ostream& os) { return generator_->indent(os); }
-
-  void indent_up() { generator_->indent_up(); }
-  void indent_down() { generator_->indent_down(); }
-
-  t_cpp_generator* generator_;
-  t_service* service_;
-  std::ostream& f_header_;
-  std::ostream& f_out_;
-  string service_name_;
-  string style_;
-  string pstyle_;
-  string class_name_;
-  string if_name_;
-  string factory_class_name_;
-  string finish_cob_;
-  string finish_cob_decl_;
-  string ret_type_;
-  string call_context_;
-  string cob_arg_;
-  string call_context_arg_;
-  string call_context_decl_;
-  string template_header_;
-  string template_suffix_;
-  string typename_str_;
-  string class_suffix_;
-  string extends_;
-};
-
-ProcessorGenerator::ProcessorGenerator(t_cpp_generator* generator,
-                                       t_service* service,
-                                       const string& style)
-  : generator_(generator),
-    service_(service),
-    f_header_(generator->f_header_),
-    f_out_(generator->gen_templates_ ? generator->f_service_tcc_ : generator->f_service_),
-    service_name_(generator->service_name_),
-    style_(style) {
-  if (style_ == "Cob") {
-    pstyle_ = "Async";
-    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)>, ";
-    cob_arg_ = "cob, ";
-    ret_type_ = "void ";
-  } else {
-    class_name_ = service_name_ + "Processor";
-    if_name_ = service_name_ + "If";
-
-    ret_type_ = "bool ";
-    // TODO(edhall) callContext should eventually be added to TAsyncProcessor
-    call_context_ = ", void* callContext";
-    call_context_arg_ = ", callContext";
-    call_context_decl_ = ", void*";
-  }
-
-  factory_class_name_ = class_name_ + "Factory";
-
-  if (generator->gen_templates_) {
-    template_header_ = "template <class Protocol_>\n";
-    template_suffix_ = "<Protocol_>";
-    typename_str_ = "typename ";
-    class_name_ += "T";
-    factory_class_name_ += "T";
-  }
-
-  if (service_->get_extends() != NULL) {
-    extends_ = type_name(service_->get_extends()) + pstyle_ + "Processor";
-    if (generator_->gen_templates_) {
-      // TODO(simpkins): If gen_templates_ is enabled, we currently assume all
-      // parent services were also generated with templates enabled.
-      extends_ += "T<Protocol_>";
-    }
-  }
-}
-
-void ProcessorGenerator::generate_class_definition() {
-  // Generate the dispatch methods
-  vector<t_function*> functions = service_->get_functions();
-  vector<t_function*>::iterator f_iter;
-
-  string parent_class;
-  if (service_->get_extends() != NULL) {
-    parent_class = extends_;
-  } else {
-    if (style_ == "Cob") {
-      parent_class = "::apache::thrift::async::TAsyncDispatchProcessor";
-    } else {
-      parent_class = "::apache::thrift::TDispatchProcessor";
-    }
-
-    if (generator_->gen_templates_) {
-      parent_class += "T<Protocol_>";
-    }
-  }
-
-  // Generate the header portion
-  f_header_ << template_header_ << "class " << class_name_ << " : public " << parent_class << " {"
-            << endl;
-
-  // Protected data members
-  f_header_ << " protected:" << endl;
-  indent_up();
-  f_header_ << indent() << "::apache::thrift::stdcxx::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, "
-            << "const std::string& fname, int32_t seqid" << call_context_ << ");" << endl;
-  if (generator_->gen_templates_) {
-    f_header_ << indent() << "virtual " << ret_type_ << "dispatchCallTemplated(" << finish_cob_
-              << "Protocol_* iprot, Protocol_* oprot, "
-              << "const std::string& fname, int32_t seqid" << call_context_ << ");" << endl;
-  }
-  indent_down();
-
-  // Process function declarations
-  f_header_ << " private:" << endl;
-  indent_up();
-
-  // Declare processMap_
-  f_header_ << indent() << "typedef  void (" << class_name_ << "::*"
-            << "ProcessFunction)(" << finish_cob_decl_ << "int32_t, "
-            << "::apache::thrift::protocol::TProtocol*, "
-            << "::apache::thrift::protocol::TProtocol*" << call_context_decl_ << ");" << endl;
-  if (generator_->gen_templates_) {
-    f_header_ << indent() << "typedef void (" << class_name_ << "::*"
-              << "SpecializedProcessFunction)(" << finish_cob_decl_ << "int32_t, "
-              << "Protocol_*, Protocol_*" << call_context_decl_ << ");" << endl << indent()
-              << "struct ProcessFunctions {" << endl << indent() << "  ProcessFunction generic;"
-              << endl << indent() << "  SpecializedProcessFunction specialized;" << endl << indent()
-              << "  ProcessFunctions(ProcessFunction g, "
-              << "SpecializedProcessFunction s) :" << endl << indent() << "    generic(g)," << endl
-              << indent() << "    specialized(s) {}" << endl << indent()
-              << "  ProcessFunctions() : generic(NULL), specialized(NULL) "
-              << "{}" << endl << indent() << "};" << endl << indent()
-              << "typedef std::map<std::string, ProcessFunctions> "
-              << "ProcessMap;" << endl;
-  } else {
-    f_header_ << indent() << "typedef std::map<std::string, ProcessFunction> "
-              << "ProcessMap;" << endl;
-  }
-  f_header_ << indent() << "ProcessMap processMap_;" << endl;
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    indent(f_header_) << "void process_" << (*f_iter)->get_name() << "(" << finish_cob_
-                      << "int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, "
-                         "::apache::thrift::protocol::TProtocol* oprot" << call_context_ << ");"
-                      << endl;
-    if (generator_->gen_templates_) {
-      indent(f_header_) << "void process_" << (*f_iter)->get_name() << "(" << finish_cob_
-                        << "int32_t seqid, Protocol_* iprot, Protocol_* oprot" << call_context_
-                        << ");" << endl;
-    }
-    if (style_ == "Cob") {
-      // XXX Factor this out, even if it is a pain.
-      string ret_arg = ((*f_iter)->get_returntype()->is_void()
-                            ? ""
-                            : ", 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, "
-                << "::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, "
-                  << "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, "
-                << "::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, "
-                  << "Protocol_* oprot, void* ctx, "
-                  << "::apache::thrift::TDelayedException* _throw);" << endl;
-      }
-    }
-  }
-
-  f_header_ << " public:" << endl << indent() << class_name_ << "(::apache::thrift::stdcxx::shared_ptr<" << if_name_
-            << "> iface) :" << endl;
-  if (!extends_.empty()) {
-    f_header_ << indent() << "  " << extends_ << "(iface)," << endl;
-  }
-  f_header_ << indent() << "  iface_(iface) {" << endl;
-  indent_up();
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    f_header_ << indent() << "processMap_[\"" << (*f_iter)->get_name() << "\"] = ";
-    if (generator_->gen_templates_) {
-      f_header_ << "ProcessFunctions(" << endl;
-      if (generator_->gen_templates_only_) {
-        indent(f_header_) << "  NULL," << endl;
-      } else {
-        indent(f_header_) << "  &" << class_name_ << "::process_" << (*f_iter)->get_name() << ","
-                          << endl;
-      }
-      indent(f_header_) << "  &" << class_name_ << "::process_" << (*f_iter)->get_name() << ")";
-    } else {
-      f_header_ << "&" << class_name_ << "::process_" << (*f_iter)->get_name();
-    }
-    f_header_ << ";" << endl;
-  }
-
-  indent_down();
-  f_header_ << indent() << "}" << endl << endl << indent() << "virtual ~" << class_name_ << "() {}"
-            << endl;
-  indent_down();
-  f_header_ << "};" << endl << endl;
-
-  if (generator_->gen_templates_) {
-    // Generate a backwards compatible typedef, for callers who don't know
-    // about the new template-style code.
-    //
-    // We can't use TProtocol as the template parameter, since ProcessorT
-    // provides overloaded versions of most methods, one of which accepts
-    // TProtocol pointers, and one which accepts Protocol_ pointers.  This
-    // results in a compile error if instantiated with Protocol_ == TProtocol.
-    // Therefore, we define TDummyProtocol solely so we can use it as the
-    // template parameter here.
-    f_header_ << "typedef " << class_name_ << "< ::apache::thrift::protocol::TDummyProtocol > "
-              << service_name_ << pstyle_ << "Processor;" << endl << endl;
-  }
-}
-
-void ProcessorGenerator::generate_dispatch_call(bool template_protocol) {
-  string protocol = "::apache::thrift::protocol::TProtocol";
-  string function_suffix;
-  if (template_protocol) {
-    protocol = "Protocol_";
-    // We call the generic version dispatchCall(), and the specialized
-    // version dispatchCallTemplated().  We can't call them both
-    // dispatchCall(), since this will cause the compiler to issue a warning if
-    // a service that doesn't use templates inherits from a service that does
-    // use templates: the compiler complains that the subclass only implements
-    // the generic version of dispatchCall(), and hides the templated version.
-    // Using different names for the two functions prevents this.
-    function_suffix = "Templated";
-  }
-
-  f_out_ << template_header_ << ret_type_ << class_name_ << template_suffix_ << "::dispatchCall"
-         << function_suffix << "(" << finish_cob_ << protocol << "* iprot, " << protocol
-         << "* oprot, "
-         << "const std::string& fname, int32_t seqid" << call_context_ << ") {" << endl;
-  indent_up();
-
-  // HOT: member function pointer map
-  f_out_ << indent() << typename_str_ << "ProcessMap::iterator pfn;" << endl << indent()
-         << "pfn = processMap_.find(fname);" << endl << indent()
-         << "if (pfn == processMap_.end()) {" << endl;
-  if (extends_.empty()) {
-    f_out_ << indent() << "  iprot->skip(::apache::thrift::protocol::T_STRUCT);" << endl << indent()
-           << "  iprot->readMessageEnd();" << endl << indent()
-           << "  iprot->getTransport()->readEnd();" << endl << indent()
-           << "  ::apache::thrift::TApplicationException "
-              "x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, \"Invalid method name: "
-              "'\"+fname+\"'\");" << endl << indent()
-           << "  oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);"
-           << endl << indent() << "  x.write(oprot);" << endl << indent()
-           << "  oprot->writeMessageEnd();" << endl << indent()
-           << "  oprot->getTransport()->writeEnd();" << endl << indent()
-           << "  oprot->getTransport()->flush();" << endl << indent()
-           << (style_ == "Cob" ? "  return cob(true);" : "  return true;") << endl;
-  } else {
-    f_out_ << indent() << "  return " << extends_ << "::dispatchCall("
-           << (style_ == "Cob" ? "cob, " : "") << "iprot, oprot, fname, seqid" << call_context_arg_
-           << ");" << endl;
-  }
-  f_out_ << indent() << "}" << endl;
-  if (template_protocol) {
-    f_out_ << indent() << "(this->*(pfn->second.specialized))";
-  } else {
-    if (generator_->gen_templates_only_) {
-      // TODO: This is a null pointer, so nothing good will come from calling
-      // it.  Throw an exception instead.
-      f_out_ << indent() << "(this->*(pfn->second.generic))";
-    } else if (generator_->gen_templates_) {
-      f_out_ << indent() << "(this->*(pfn->second.generic))";
-    } else {
-      f_out_ << indent() << "(this->*(pfn->second))";
-    }
-  }
-  f_out_ << "(" << cob_arg_ << "seqid, iprot, oprot" << call_context_arg_ << ");" << endl;
-
-  // TODO(dreiss): return pfn ret?
-  if (style_ == "Cob") {
-    f_out_ << indent() << "return;" << endl;
-  } else {
-    f_out_ << indent() << "return true;" << endl;
-  }
-
-  indent_down();
-  f_out_ << "}" << endl << endl;
-}
-
-void ProcessorGenerator::generate_process_functions() {
-  vector<t_function*> functions = service_->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    if (generator_->gen_templates_) {
-      generator_->generate_process_function(service_, *f_iter, style_, false);
-      generator_->generate_process_function(service_, *f_iter, style_, true);
-    } else {
-      generator_->generate_process_function(service_, *f_iter, style_, false);
-    }
-  }
-}
-
-void ProcessorGenerator::generate_factory() {
-  string if_factory_name = if_name_ + "Factory";
-
-  // Generate the factory class definition
-  f_header_ << template_header_ << "class " << factory_class_name_ << " : public ::apache::thrift::"
-            << (style_ == "Cob" ? "async::TAsyncProcessorFactory" : "TProcessorFactory") << " {"
-            << endl << " public:" << endl;
-  indent_up();
-
-  f_header_ << indent() << factory_class_name_ << "(const ::apache::thrift::stdcxx::shared_ptr< " << if_factory_name
-            << " >& handlerFactory) :" << endl << indent()
-            << "    handlerFactory_(handlerFactory) {}" << endl << endl << indent()
-            << "::apache::thrift::stdcxx::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< "
-            << if_factory_name << " > handlerFactory_;" << endl;
-
-  indent_down();
-  f_header_ << "};" << endl << endl;
-
-  // If we are generating templates, output a typedef for the plain
-  // factory name.
-  if (generator_->gen_templates_) {
-    f_header_ << "typedef " << factory_class_name_
-              << "< ::apache::thrift::protocol::TDummyProtocol > " << service_name_ << pstyle_
-              << "ProcessorFactory;" << endl << endl;
-  }
-
-  // Generate the getProcessor() method
-  f_out_ << template_header_ << indent() << "::apache::thrift::stdcxx::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< "
-         << if_name_ << " > handler("
-         << "handlerFactory_->getHandler(connInfo), cleanup);" << endl << indent()
-         << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::"
-         << (style_ == "Cob" ? "async::TAsyncProcessor" : "TProcessor") << " > "
-         << "processor(new " << class_name_ << template_suffix_ << "(handler));" << endl << indent()
-         << "return processor;" << endl;
-
-  indent_down();
-  f_out_ << indent() << "}" << endl << endl;
-}
-
-/**
- * Generates a service processor definition.
- *
- * @param tservice The service to generate a processor for.
- */
-void t_cpp_generator::generate_service_processor(t_service* tservice, string style) {
-  ProcessorGenerator generator(this, tservice, style);
-  generator.run();
-}
-
-/**
- * Generates a struct and helpers for a function.
- *
- * @param tfunction The function
- */
-void t_cpp_generator::generate_function_helpers(t_service* tservice, t_function* tfunction) {
-  if (tfunction->is_oneway()) {
-    return;
-  }
-
-  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_);
-
-  t_struct result(program_, tservice->get_name() + "_" + tfunction->get_name() + "_result");
-  t_field success(tfunction->get_returntype(), "success", 0);
-  if (!tfunction->get_returntype()->is_void()) {
-    result.append(&success);
-  }
-
-  t_struct* xs = tfunction->get_xceptions();
-  const vector<t_field*>& fields = xs->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    result.append(*f_iter);
-  }
-
-  generate_struct_declaration(f_header_, &result, false);
-  generate_struct_definition(out, f_service_, &result, false);
-  generate_struct_reader(out, &result);
-  generate_struct_result_writer(out, &result);
-
-  result.set_name(tservice->get_name() + "_" + tfunction->get_name() + "_presult");
-  generate_struct_declaration(f_header_, &result, false, true, true, gen_cob_style_);
-  generate_struct_definition(out, f_service_, &result, false);
-  generate_struct_reader(out, &result, true);
-  if (gen_cob_style_) {
-    generate_struct_writer(out, &result, true);
-  }
-}
-
-/**
- * Generates a process function definition.
- *
- * @param tfunction The function to write a dispatcher for
- */
-void t_cpp_generator::generate_process_function(t_service* tservice,
-                                                t_function* tfunction,
-                                                string style,
-                                                bool specialized) {
-  t_struct* arg_struct = tfunction->get_arglist();
-  const std::vector<t_field*>& fields = arg_struct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  t_struct* xs = tfunction->get_xceptions();
-  const std::vector<t_field*>& xceptions = xs->get_members();
-  vector<t_field*>::const_iterator x_iter;
-  string service_func_name = "\"" + tservice->get_name() + "." + tfunction->get_name() + "\"";
-
-  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_);
-
-  string prot_type = (specialized ? "Protocol_" : "::apache::thrift::protocol::TProtocol");
-  string class_suffix;
-  if (gen_templates_) {
-    class_suffix = "T<Protocol_>";
-  }
-
-  // I tried to do this as one function.  I really did.  But it was too hard.
-  if (style != "Cob") {
-    // Open function
-    if (gen_templates_) {
-      out << indent() << "template <class Protocol_>" << endl;
-    }
-    const bool unnamed_oprot_seqid = tfunction->is_oneway() && !(gen_templates_ && !specialized);
-    out << "void " << tservice->get_name() << "Processor" << class_suffix << "::"
-        << "process_" << tfunction->get_name() << "("
-        << "int32_t" << (unnamed_oprot_seqid ? ", " : " seqid, ") << prot_type << "* iprot, "
-        << prot_type << "*" << (unnamed_oprot_seqid ? ", " : " oprot, ") << "void* callContext)"
-        << endl;
-    scope_up(out);
-
-    string argsname = tservice->get_name() + "_" + tfunction->get_name() + "_args";
-    string resultname = tservice->get_name() + "_" + tfunction->get_name() + "_result";
-
-    if (tfunction->is_oneway() && !unnamed_oprot_seqid) {
-      out << indent() << "(void) seqid;" << endl << indent() << "(void) oprot;" << endl;
-    }
-
-    out << indent() << "void* ctx = NULL;" << endl << indent()
-        << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", callContext);"
-        << endl << indent() << "}" << endl << indent()
-        << "::apache::thrift::TProcessorContextFreer freer("
-        << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl
-        << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  this->eventHandler_->preRead(ctx, " << service_func_name << ");" << endl << indent()
-        << "}" << endl << endl << indent() << argsname << " args;" << endl << indent()
-        << "args.read(iprot);" << endl << indent() << "iprot->readMessageEnd();" << endl << indent()
-        << "uint32_t bytes = iprot->getTransport()->readEnd();" << endl << endl << indent()
-        << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  this->eventHandler_->postRead(ctx, " << service_func_name << ", bytes);" << endl
-        << indent() << "}" << endl << endl;
-
-    // Declare result
-    if (!tfunction->is_oneway()) {
-      out << indent() << resultname << " result;" << endl;
-    }
-
-    // Try block for functions with exceptions
-    out << indent() << "try {" << endl;
-    indent_up();
-
-    // Generate the function call
-    bool first = true;
-    out << indent();
-    if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) {
-      if (is_complex_type(tfunction->get_returntype())) {
-        first = false;
-        out << "iface_->" << tfunction->get_name() << "(result.success";
-      } else {
-        out << "result.success = iface_->" << tfunction->get_name() << "(";
-      }
-    } else {
-      out << "iface_->" << tfunction->get_name() << "(";
-    }
-    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-      if (first) {
-        first = false;
-      } else {
-        out << ", ";
-      }
-      out << "args." << (*f_iter)->get_name();
-    }
-    out << ");" << endl;
-
-    // Set isset on success field
-    if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) {
-      out << indent() << "result.__isset.success = true;" << endl;
-    }
-
-    indent_down();
-    out << indent() << "}";
-
-    if (!tfunction->is_oneway()) {
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-        out << " catch (" << type_name((*x_iter)->get_type()) << " &" << (*x_iter)->get_name()
-            << ") {" << endl;
-        if (!tfunction->is_oneway()) {
-          indent_up();
-          out << indent() << "result." << (*x_iter)->get_name() << " = " << (*x_iter)->get_name()
-              << ";" << endl << indent() << "result.__isset." << (*x_iter)->get_name() << " = true;"
-              << endl;
-          indent_down();
-          out << indent() << "}";
-        } else {
-          out << "}";
-        }
-      }
-    }
-
-    if (!tfunction->is_oneway()) {
-      out << " catch (const std::exception& e) {" << endl;
-    } else {
-      out << " catch (const std::exception&) {" << endl;
-    }
-
-    indent_up();
-    out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  this->eventHandler_->handlerError(ctx, " << service_func_name << ");" << endl
-        << indent() << "}" << endl;
-
-    if (!tfunction->is_oneway()) {
-      out << endl << indent() << "::apache::thrift::TApplicationException x(e.what());" << endl
-          << indent() << "oprot->writeMessageBegin(\"" << tfunction->get_name()
-          << "\", ::apache::thrift::protocol::T_EXCEPTION, seqid);" << endl << indent()
-          << "x.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" << endl
-          << indent() << "oprot->getTransport()->writeEnd();" << endl << indent()
-          << "oprot->getTransport()->flush();" << endl;
-    }
-    out << indent() << "return;" << endl;
-    indent_down();
-    out << indent() << "}" << endl << endl;
-
-    // Shortcut out here for oneway functions
-    if (tfunction->is_oneway()) {
-      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  this->eventHandler_->asyncComplete(ctx, " << service_func_name << ");" << endl
-          << indent() << "}" << endl << endl << indent() << "return;" << endl;
-      indent_down();
-      out << "}" << endl << endl;
-      return;
-    }
-
-    // Serialize the result into a struct
-    out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  this->eventHandler_->preWrite(ctx, " << service_func_name << ");" << endl << indent()
-        << "}" << endl << endl << indent() << "oprot->writeMessageBegin(\"" << tfunction->get_name()
-        << "\", ::apache::thrift::protocol::T_REPLY, seqid);" << endl << indent()
-        << "result.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" << endl
-        << indent() << "bytes = oprot->getTransport()->writeEnd();" << endl << indent()
-        << "oprot->getTransport()->flush();" << endl << endl << indent()
-        << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  this->eventHandler_->postWrite(ctx, " << service_func_name << ", bytes);" << endl
-        << indent() << "}" << endl;
-
-    // Close function
-    scope_down(out);
-    out << endl;
-  }
-
-  // Cob style.
-  else {
-    // Processor entry point.
-    // TODO(edhall) update for callContext when TEventServer is ready
-    if (gen_templates_) {
-      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, "
-        << prot_type << "* iprot, " << prot_type << "* oprot)" << endl;
-    scope_up(out);
-
-    // TODO(simpkins): we could try to consoldate this
-    // with the non-cob code above
-    if (gen_templates_ && !specialized) {
-      // If these are instances of Protocol_, instead of any old TProtocol,
-      // use the specialized process function instead.
-      out << indent() << "Protocol_* _iprot = dynamic_cast<Protocol_*>(iprot);" << endl << indent()
-          << "Protocol_* _oprot = dynamic_cast<Protocol_*>(oprot);" << endl << indent()
-          << "if (_iprot && _oprot) {" << endl << indent() << "  return process_"
-          << tfunction->get_name() << "(cob, seqid, _iprot, _oprot);" << endl << indent() << "}"
-          << endl << indent() << "T_GENERIC_PROTOCOL(this, iprot, _iprot);" << endl << indent()
-          << "T_GENERIC_PROTOCOL(this, oprot, _oprot);" << endl << endl;
-    }
-
-    if (tfunction->is_oneway()) {
-      out << indent() << "(void) seqid;" << endl << indent() << "(void) oprot;" << endl;
-    }
-
-    out << indent() << tservice->get_name() + "_" + tfunction->get_name() << "_args args;" << endl
-        << indent() << "void* ctx = NULL;" << endl << indent()
-        << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", NULL);" << endl
-        << indent() << "}" << endl << indent() << "::apache::thrift::TProcessorContextFreer freer("
-        << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl
-        << indent() << "try {" << endl;
-    indent_up();
-    out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  this->eventHandler_->preRead(ctx, " << service_func_name << ");" << endl << indent()
-        << "}" << endl << indent() << "args.read(iprot);" << endl << indent()
-        << "iprot->readMessageEnd();" << endl << indent()
-        << "uint32_t bytes = iprot->getTransport()->readEnd();" << endl << indent()
-        << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "  this->eventHandler_->postRead(ctx, " << service_func_name << ", bytes);" << endl
-        << indent() << "}" << endl;
-    scope_down(out);
-
-    // TODO(dreiss): Handle TExceptions?  Expose to server?
-    out << indent() << "catch (const std::exception&) {" << endl << indent()
-        << "  if (this->eventHandler_.get() != NULL) {" << endl << indent()
-        << "    this->eventHandler_->handlerError(ctx, " << service_func_name << ");" << endl
-        << indent() << "  }" << endl << indent() << "  return cob(false);" << endl << indent()
-        << "}" << endl;
-
-    if (tfunction->is_oneway()) {
-      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  this->eventHandler_->asyncComplete(ctx, " << service_func_name << ");" << endl
-          << indent() << "}" << endl;
-    }
-    // TODO(dreiss): Figure out a strategy for exceptions in async handlers.
-    out << indent() << "freer.unregister();" << endl;
-    if (tfunction->is_oneway()) {
-      // 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;
-      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";
-      }
-
-      // 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)> "
-          << "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)> "
-            << "cob, int32_t seqid, " << prot_type << "* oprot, void* ctx, "
-            << "::apache::thrift::TDelayedException* _throw) =" << endl;
-        out << indent() << "  &" << tservice->get_name() << "AsyncProcessor" << class_suffix
-            << "::throw_" << tfunction->get_name() << ";" << endl;
-      }
-
-      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
-          << ")";
-      if (!xceptions.empty()) {
-        out << ',' << endl << indent() << "::apache::thrift::stdcxx::bind(throw_fn, this, cob, seqid, oprot, "
-            << "ctx, ::apache::thrift::stdcxx::placeholders::_1)";
-      }
-    }
-
-    // XXX Whitespace cleanup.
-    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-      out << ',' << endl << indent() << "args." << (*f_iter)->get_name();
-    }
-    out << ");" << endl;
-    indent_down();
-    indent_down();
-    scope_down(out);
-    out << endl;
-
-    // Normal return.
-    if (!tfunction->is_oneway()) {
-      string ret_arg_decl, ret_arg_name;
-      if (!tfunction->get_returntype()->is_void()) {
-        ret_arg_decl = ", const " + type_name(tfunction->get_returntype()) + "& _return";
-        ret_arg_name = ", _return";
-      }
-      if (gen_templates_) {
-        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, "
-          << prot_type << "* oprot, void* ctx" << ret_arg_decl << ')' << endl;
-      scope_up(out);
-
-      if (gen_templates_ && !specialized) {
-        // If oprot is a Protocol_ instance,
-        // use the specialized return function instead.
-        out << indent() << "Protocol_* _oprot = dynamic_cast<Protocol_*>(oprot);" << endl
-            << indent() << "if (_oprot) {" << endl << indent() << "  return return_"
-            << tfunction->get_name() << "(cob, seqid, _oprot, ctx" << ret_arg_name << ");" << endl
-            << indent() << "}" << endl << indent() << "T_GENERIC_PROTOCOL(this, oprot, _oprot);"
-            << endl << endl;
-      }
-
-      out << indent() << tservice->get_name() << "_" << tfunction->get_name() << "_presult result;"
-          << endl;
-      if (!tfunction->get_returntype()->is_void()) {
-        // The const_cast here is unfortunate, but it would be a pain to avoid,
-        // and we only do a write with this struct, which is const-safe.
-        out << indent() << "result.success = const_cast<" << type_name(tfunction->get_returntype())
-            << "*>(&_return);" << endl << indent() << "result.__isset.success = true;" << endl;
-      }
-      // Serialize the result into a struct
-      out << endl << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", NULL);" << endl
-          << indent() << "}" << endl << indent()
-          << "::apache::thrift::TProcessorContextFreer freer("
-          << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl
-          << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  this->eventHandler_->preWrite(ctx, " << service_func_name << ");" << endl
-          << indent() << "}" << endl << endl << indent() << "oprot->writeMessageBegin(\""
-          << tfunction->get_name() << "\", ::apache::thrift::protocol::T_REPLY, seqid);" << endl
-          << indent() << "result.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();"
-          << endl << indent() << "uint32_t bytes = oprot->getTransport()->writeEnd();" << endl
-          << indent() << "oprot->getTransport()->flush();" << endl << indent()
-          << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  this->eventHandler_->postWrite(ctx, " << service_func_name << ", bytes);" << endl
-          << indent() << "}" << endl << indent() << "return cob(true);" << endl;
-      scope_down(out);
-      out << endl;
-    }
-
-    // Exception return.
-    if (!tfunction->is_oneway() && !xceptions.empty()) {
-      if (gen_templates_) {
-        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, "
-          << prot_type << "* oprot, void* ctx, "
-          << "::apache::thrift::TDelayedException* _throw)" << endl;
-      scope_up(out);
-
-      if (gen_templates_ && !specialized) {
-        // If oprot is a Protocol_ instance,
-        // use the specialized throw function instead.
-        out << indent() << "Protocol_* _oprot = dynamic_cast<Protocol_*>(oprot);" << endl
-            << indent() << "if (_oprot) {" << endl << indent() << "  return throw_"
-            << tfunction->get_name() << "(cob, seqid, _oprot, ctx, _throw);" << endl << indent()
-            << "}" << endl << indent() << "T_GENERIC_PROTOCOL(this, oprot, _oprot);" << endl
-            << endl;
-      }
-
-      // Get the event handler context
-      out << endl << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", NULL);" << endl
-          << indent() << "}" << endl << indent()
-          << "::apache::thrift::TProcessorContextFreer freer("
-          << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl;
-
-      // Throw the TDelayedException, and catch the result
-      out << indent() << tservice->get_name() << "_" << tfunction->get_name() << "_result result;"
-          << endl << endl << indent() << "try {" << endl;
-      indent_up();
-      out << indent() << "_throw->throw_it();" << endl << indent() << "return cob(false);"
-          << endl; // Is this possible?  TBD.
-      indent_down();
-      out << indent() << '}';
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-        out << "  catch (" << type_name((*x_iter)->get_type()) << " &" << (*x_iter)->get_name()
-            << ") {" << endl;
-        indent_up();
-        out << indent() << "result." << (*x_iter)->get_name() << " = " << (*x_iter)->get_name()
-            << ";" << endl << indent() << "result.__isset." << (*x_iter)->get_name() << " = true;"
-            << endl;
-        scope_down(out);
-      }
-
-      // Handle the case where an undeclared exception is thrown
-      out << " catch (std::exception& e) {" << endl;
-      indent_up();
-      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  this->eventHandler_->handlerError(ctx, " << service_func_name << ");" << endl
-          << indent() << "}" << endl << endl << indent()
-          << "::apache::thrift::TApplicationException x(e.what());" << endl << indent()
-          << "oprot->writeMessageBegin(\"" << tfunction->get_name()
-          << "\", ::apache::thrift::protocol::T_EXCEPTION, seqid);" << endl << indent()
-          << "x.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" << endl
-          << indent() << "oprot->getTransport()->writeEnd();" << endl << indent()
-          << "oprot->getTransport()->flush();" << endl <<
-          // We pass true to the cob here, since we did successfully write a
-          // response, even though it is an exception response.
-          // It looks like the argument is currently ignored, anyway.
-          indent() << "return cob(true);" << endl;
-      scope_down(out);
-
-      // Serialize the result into a struct
-      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  this->eventHandler_->preWrite(ctx, " << service_func_name << ");" << endl
-          << indent() << "}" << endl << endl << indent() << "oprot->writeMessageBegin(\""
-          << tfunction->get_name() << "\", ::apache::thrift::protocol::T_REPLY, seqid);" << endl
-          << indent() << "result.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();"
-          << endl << indent() << "uint32_t bytes = oprot->getTransport()->writeEnd();" << endl
-          << indent() << "oprot->getTransport()->flush();" << endl << indent()
-          << "if (this->eventHandler_.get() != NULL) {" << endl << indent()
-          << "  this->eventHandler_->postWrite(ctx, " << service_func_name << ", bytes);" << endl
-          << indent() << "}" << endl << indent() << "return cob(true);" << endl;
-      scope_down(out);
-      out << endl;
-    } // for each function
-  }   // cob style
-}
-
-/**
- * Generates a skeleton file of a server
- *
- * @param tservice The service to generate a server for.
- */
-void t_cpp_generator::generate_service_skeleton(t_service* tservice) {
-  string svcname = tservice->get_name();
-
-  // Service implementation file includes
-  string f_skeleton_name = get_out_dir() + svcname + "_server.skeleton.cpp";
-
-  string ns = namespace_prefix(tservice->get_program()->get_namespace("cpp"));
-
-  ofstream_with_content_based_conditional_update f_skeleton;
-  f_skeleton.open(f_skeleton_name.c_str());
-  f_skeleton << "// This autogenerated skeleton file illustrates how to build a server." << endl
-             << "// You should copy it to another filename to avoid overwriting it." << endl << endl
-             << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\"" << endl
-             << "#include <thrift/protocol/TBinaryProtocol.h>" << endl
-             << "#include <thrift/server/TSimpleServer.h>" << endl
-             << "#include <thrift/transport/TServerSocket.h>" << endl
-             << "#include <thrift/transport/TBufferTransports.h>" << endl << endl
-             << "using namespace ::apache::thrift;" << endl
-             << "using namespace ::apache::thrift::protocol;" << endl
-             << "using namespace ::apache::thrift::transport;" << endl
-             << "using namespace ::apache::thrift::server;" << endl << endl;
-
-  // the following code would not compile:
-  // using namespace ;
-  // using namespace ::;
-  if ((!ns.empty()) && (ns.compare(" ::") != 0)) {
-    f_skeleton << "using namespace " << string(ns, 0, ns.size() - 2) << ";" << endl << endl;
-  }
-
-  f_skeleton << "class " << svcname << "Handler : virtual public " << svcname << "If {" << endl
-             << " public:" << endl;
-  indent_up();
-  f_skeleton << indent() << svcname << "Handler() {" << endl << indent()
-             << "  // Your initialization goes here" << endl << indent() << "}" << endl << endl;
-
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_java_doc(f_skeleton, *f_iter);
-    f_skeleton << indent() << function_signature(*f_iter, "") << " {" << endl << indent()
-               << "  // Your implementation goes here" << endl << indent() << "  printf(\""
-               << (*f_iter)->get_name() << "\\n\");" << endl << indent() << "}" << endl << endl;
-  }
-
-  indent_down();
-  f_skeleton << "};" << endl << endl;
-
-  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
-      << "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));"
-      << endl << indent()
-      << "::apache::thrift::stdcxx::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());" << endl
-      << indent() << "::apache::thrift::stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());"
-      << endl << endl << indent()
-      << "TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);"
-      << endl << indent() << "server.serve();" << endl << indent() << "return 0;" << endl;
-  indent_down();
-  f_skeleton << "}" << endl << endl;
-
-  // Close the files
-  f_skeleton.close();
-}
-
-/**
- * Deserializes a field of any type.
- */
-void t_cpp_generator::generate_deserialize_field(ostream& out,
-                                                 t_field* tfield,
-                                                 string prefix,
-                                                 string suffix) {
-  t_type* type = get_true_type(tfield->get_type());
-
-  if (type->is_void()) {
-    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name();
-  }
-
-  string name = prefix + tfield->get_name() + suffix;
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_deserialize_struct(out, (t_struct*)type, name, is_reference(tfield));
-  } else if (type->is_container()) {
-    generate_deserialize_container(out, type, name);
-  } else if (type->is_base_type()) {
-    indent(out) << "xfer += iprot->";
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "compiler error: cannot serialize void field in a struct: " + name;
-      break;
-    case t_base_type::TYPE_STRING:
-      if (type->is_binary()) {
-        out << "readBinary(" << name << ");";
-      } else {
-        out << "readString(" << name << ");";
-      }
-      break;
-    case t_base_type::TYPE_BOOL:
-      out << "readBool(" << name << ");";
-      break;
-    case t_base_type::TYPE_I8:
-      out << "readByte(" << name << ");";
-      break;
-    case t_base_type::TYPE_I16:
-      out << "readI16(" << name << ");";
-      break;
-    case t_base_type::TYPE_I32:
-      out << "readI32(" << name << ");";
-      break;
-    case t_base_type::TYPE_I64:
-      out << "readI64(" << name << ");";
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      out << "readDouble(" << name << ");";
-      break;
-    default:
-      throw "compiler error: no C++ reader for base type " + t_base_type::t_base_name(tbase) + name;
-    }
-    out << endl;
-  } else if (type->is_enum()) {
-    string t = tmp("ecast");
-    out << indent() << "int32_t " << t << ";" << endl << indent() << "xfer += iprot->readI32(" << t
-        << ");" << endl << indent() << name << " = (" << type_name(type) << ")" << t << ";" << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n",
-           tfield->get_name().c_str(),
-           type_name(type).c_str());
-  }
-}
-
-/**
- * Generates an unserializer for a variable. This makes two key assumptions,
- * first that there is a const char* variable named data that points to the
- * buffer for deserialization, and that there is a variable protocol which
- * is a reference to a TProtocol serialization object.
- */
-void t_cpp_generator::generate_deserialize_struct(ostream& out,
-                                                  t_struct* tstruct,
-                                                  string prefix,
-                                                  bool pointer) {
-  if (pointer) {
-    indent(out) << "if (!" << prefix << ") { " << endl;
-    indent(out) << "  " << prefix << " = ::apache::thrift::stdcxx::shared_ptr<" << type_name(tstruct) << ">(new "
-                << type_name(tstruct) << ");" << endl;
-    indent(out) << "}" << endl;
-    indent(out) << "xfer += " << prefix << "->read(iprot);" << endl;
-    indent(out) << "bool wasSet = false;" << endl;
-    const vector<t_field*>& members = tstruct->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    for (f_iter = members.begin(); f_iter != members.end(); ++f_iter) {
-
-      indent(out) << "if (" << prefix << "->__isset." << (*f_iter)->get_name()
-                  << ") { wasSet = true; }" << endl;
-    }
-    indent(out) << "if (!wasSet) { " << prefix << ".reset(); }" << endl;
-  } else {
-    indent(out) << "xfer += " << prefix << ".read(iprot);" << endl;
-  }
-}
-
-void t_cpp_generator::generate_deserialize_container(ostream& out, t_type* ttype, string prefix) {
-  scope_up(out);
-
-  string size = tmp("_size");
-  string ktype = tmp("_ktype");
-  string vtype = tmp("_vtype");
-  string etype = tmp("_etype");
-
-  t_container* tcontainer = (t_container*)ttype;
-  bool use_push = tcontainer->has_cpp_name();
-
-  indent(out) << prefix << ".clear();" << endl << indent() << "uint32_t " << size << ";" << endl;
-
-  // Declare variables, read header
-  if (ttype->is_map()) {
-    out << indent() << "::apache::thrift::protocol::TType " << ktype << ";" << endl << indent()
-        << "::apache::thrift::protocol::TType " << vtype << ";" << endl << indent()
-        << "xfer += iprot->readMapBegin(" << ktype << ", " << vtype << ", " << size << ");" << endl;
-  } else if (ttype->is_set()) {
-    out << indent() << "::apache::thrift::protocol::TType " << etype << ";" << endl << indent()
-        << "xfer += iprot->readSetBegin(" << etype << ", " << size << ");" << endl;
-  } else if (ttype->is_list()) {
-    out << indent() << "::apache::thrift::protocol::TType " << etype << ";" << endl << indent()
-        << "xfer += iprot->readListBegin(" << etype << ", " << size << ");" << endl;
-    if (!use_push) {
-      indent(out) << prefix << ".resize(" << size << ");" << endl;
-    }
-  }
-
-  // For loop iterates over elements
-  string i = tmp("_i");
-  out << indent() << "uint32_t " << i << ";" << endl << indent() << "for (" << i << " = 0; " << i
-      << " < " << size << "; ++" << i << ")" << endl;
-
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    generate_deserialize_map_element(out, (t_map*)ttype, prefix);
-  } else if (ttype->is_set()) {
-    generate_deserialize_set_element(out, (t_set*)ttype, prefix);
-  } else if (ttype->is_list()) {
-    generate_deserialize_list_element(out, (t_list*)ttype, prefix, use_push, i);
-  }
-
-  scope_down(out);
-
-  // Read container end
-  if (ttype->is_map()) {
-    indent(out) << "xfer += iprot->readMapEnd();" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "xfer += iprot->readSetEnd();" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "xfer += iprot->readListEnd();" << endl;
-  }
-
-  scope_down(out);
-}
-
-/**
- * Generates code to deserialize a map
- */
-void t_cpp_generator::generate_deserialize_map_element(ostream& out, t_map* tmap, string prefix) {
-  string key = tmp("_key");
-  string val = tmp("_val");
-  t_field fkey(tmap->get_key_type(), key);
-  t_field fval(tmap->get_val_type(), val);
-
-  out << indent() << declare_field(&fkey) << endl;
-
-  generate_deserialize_field(out, &fkey);
-  indent(out) << declare_field(&fval, false, false, false, true) << " = " << prefix << "[" << key
-              << "];" << endl;
-
-  generate_deserialize_field(out, &fval);
-}
-
-void t_cpp_generator::generate_deserialize_set_element(ostream& out, t_set* tset, string prefix) {
-  string elem = tmp("_elem");
-  t_field felem(tset->get_elem_type(), elem);
-
-  indent(out) << declare_field(&felem) << endl;
-
-  generate_deserialize_field(out, &felem);
-
-  indent(out) << prefix << ".insert(" << elem << ");" << endl;
-}
-
-void t_cpp_generator::generate_deserialize_list_element(ostream& out,
-                                                        t_list* tlist,
-                                                        string prefix,
-                                                        bool use_push,
-                                                        string index) {
-  if (use_push) {
-    string elem = tmp("_elem");
-    t_field felem(tlist->get_elem_type(), elem);
-    indent(out) << declare_field(&felem) << endl;
-    generate_deserialize_field(out, &felem);
-    indent(out) << prefix << ".push_back(" << elem << ");" << endl;
-  } else {
-    t_field felem(tlist->get_elem_type(), prefix + "[" + index + "]");
-    generate_deserialize_field(out, &felem);
-  }
-}
-
-/**
- * Serializes a field of any type.
- *
- * @param tfield The field to serialize
- * @param prefix Name to prepend to field name
- */
-void t_cpp_generator::generate_serialize_field(ostream& out,
-                                               t_field* tfield,
-                                               string prefix,
-                                               string suffix) {
-  t_type* type = get_true_type(tfield->get_type());
-
-  string name = prefix + tfield->get_name() + suffix;
-
-  // Do nothing for void types
-  if (type->is_void()) {
-    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + name;
-  }
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_serialize_struct(out, (t_struct*)type, name, is_reference(tfield));
-  } else if (type->is_container()) {
-    generate_serialize_container(out, type, name);
-  } else if (type->is_base_type() || type->is_enum()) {
-
-    indent(out) << "xfer += oprot->";
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + name;
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "writeBinary(" << name << ");";
-        } else {
-          out << "writeString(" << name << ");";
-        }
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "writeBool(" << name << ");";
-        break;
-      case t_base_type::TYPE_I8:
-        out << "writeByte(" << name << ");";
-        break;
-      case t_base_type::TYPE_I16:
-        out << "writeI16(" << name << ");";
-        break;
-      case t_base_type::TYPE_I32:
-        out << "writeI32(" << name << ");";
-        break;
-      case t_base_type::TYPE_I64:
-        out << "writeI64(" << name << ");";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "writeDouble(" << name << ");";
-        break;
-      default:
-        throw "compiler error: no C++ writer for base type " + t_base_type::t_base_name(tbase)
-            + name;
-      }
-    } else if (type->is_enum()) {
-      out << "writeI32((int32_t)" << name << ");";
-    }
-    out << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s' TYPE '%s'\n",
-           name.c_str(),
-           type_name(type).c_str());
-  }
-}
-
-/**
- * Serializes all the members of a struct.
- *
- * @param tstruct The struct to serialize
- * @param prefix  String prefix to attach to all fields
- */
-void t_cpp_generator::generate_serialize_struct(ostream& out,
-                                                t_struct* tstruct,
-                                                string prefix,
-                                                bool pointer) {
-  if (pointer) {
-    indent(out) << "if (" << prefix << ") {" << endl;
-    indent(out) << "  xfer += " << prefix << "->write(oprot); " << endl;
-    indent(out) << "} else {"
-                << "oprot->writeStructBegin(\"" << tstruct->get_name() << "\"); " << endl;
-    indent(out) << "  oprot->writeStructEnd();" << endl;
-    indent(out) << "  oprot->writeFieldStop();" << endl;
-    indent(out) << "}" << endl;
-  } else {
-    indent(out) << "xfer += " << prefix << ".write(oprot);" << endl;
-  }
-}
-
-void t_cpp_generator::generate_serialize_container(ostream& out, t_type* ttype, string prefix) {
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "xfer += oprot->writeMapBegin(" << type_to_enum(((t_map*)ttype)->get_key_type())
-                << ", " << type_to_enum(((t_map*)ttype)->get_val_type()) << ", "
-                << "static_cast<uint32_t>(" << prefix << ".size()));" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "xfer += oprot->writeSetBegin(" << type_to_enum(((t_set*)ttype)->get_elem_type())
-                << ", "
-                << "static_cast<uint32_t>(" << prefix << ".size()));" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "xfer += oprot->writeListBegin("
-                << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", "
-                << "static_cast<uint32_t>(" << prefix << ".size()));" << endl;
-  }
-
-  string iter = tmp("_iter");
-  out << indent() << type_name(ttype) << "::const_iterator " << iter << ";" << endl << indent()
-      << "for (" << iter << " = " << prefix << ".begin(); " << iter << " != " << prefix
-      << ".end(); ++" << iter << ")" << endl;
-  scope_up(out);
-  if (ttype->is_map()) {
-    generate_serialize_map_element(out, (t_map*)ttype, iter);
-  } else if (ttype->is_set()) {
-    generate_serialize_set_element(out, (t_set*)ttype, iter);
-  } else if (ttype->is_list()) {
-    generate_serialize_list_element(out, (t_list*)ttype, iter);
-  }
-  scope_down(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "xfer += oprot->writeMapEnd();" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "xfer += oprot->writeSetEnd();" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "xfer += oprot->writeListEnd();" << endl;
-  }
-
-  scope_down(out);
-}
-
-/**
- * Serializes the members of a map.
- *
- */
-void t_cpp_generator::generate_serialize_map_element(ostream& out, t_map* tmap, string iter) {
-  t_field kfield(tmap->get_key_type(), iter + "->first");
-  generate_serialize_field(out, &kfield, "");
-
-  t_field vfield(tmap->get_val_type(), iter + "->second");
-  generate_serialize_field(out, &vfield, "");
-}
-
-/**
- * Serializes the members of a set.
- */
-void t_cpp_generator::generate_serialize_set_element(ostream& out, t_set* tset, string iter) {
-  t_field efield(tset->get_elem_type(), "(*" + iter + ")");
-  generate_serialize_field(out, &efield, "");
-}
-
-/**
- * Serializes the members of a list.
- */
-void t_cpp_generator::generate_serialize_list_element(ostream& out, t_list* tlist, string iter) {
-  t_field efield(tlist->get_elem_type(), "(*" + iter + ")");
-  generate_serialize_field(out, &efield, "");
-}
-
-/**
- * Makes a :: prefix for a namespace
- *
- * @param ns The namespace, w/ periods in it
- * @return Namespaces
- */
-string t_cpp_generator::namespace_prefix(string ns) {
-  // Always start with "::", to avoid possible name collisions with
-  // other names in one of the current namespaces.
-  //
-  // We also need a leading space, in case the name is used inside of a
-  // template parameter.  "MyTemplate<::foo::Bar>" is not valid C++,
-  // since "<:" is an alternative token for "[".
-  string result = " ::";
-
-  if (ns.size() == 0) {
-    return result;
-  }
-  string::size_type loc;
-  while ((loc = ns.find(".")) != string::npos) {
-    result += ns.substr(0, loc);
-    result += "::";
-    ns = ns.substr(loc + 1);
-  }
-  if (ns.size() > 0) {
-    result += ns + "::";
-  }
-  return result;
-}
-
-/**
- * Opens namespace.
- *
- * @param ns The namespace, w/ periods in it
- * @return Namespaces
- */
-string t_cpp_generator::namespace_open(string ns) {
-  if (ns.size() == 0) {
-    return "";
-  }
-  string result = "";
-  string separator = "";
-  string::size_type loc;
-  while ((loc = ns.find(".")) != string::npos) {
-    result += separator;
-    result += "namespace ";
-    result += ns.substr(0, loc);
-    result += " {";
-    separator = " ";
-    ns = ns.substr(loc + 1);
-  }
-  if (ns.size() > 0) {
-    result += separator + "namespace " + ns + " {";
-  }
-  return result;
-}
-
-/**
- * Closes namespace.
- *
- * @param ns The namespace, w/ periods in it
- * @return Namespaces
- */
-string t_cpp_generator::namespace_close(string ns) {
-  if (ns.size() == 0) {
-    return "";
-  }
-  string result = "}";
-  string::size_type loc;
-  while ((loc = ns.find(".")) != string::npos) {
-    result += "}";
-    ns = ns.substr(loc + 1);
-  }
-  result += " // namespace";
-  return result;
-}
-
-/**
- * Returns a C++ type name
- *
- * @param ttype The type
- * @return String of the type name, i.e. std::set<type>
- */
-string t_cpp_generator::type_name(t_type* ttype, bool in_typedef, bool arg) {
-  if (ttype->is_base_type()) {
-    string bname = base_type_name(((t_base_type*)ttype)->get_base());
-    std::map<string, string>::iterator it = ttype->annotations_.find("cpp.type");
-    if (it != ttype->annotations_.end()) {
-      bname = it->second;
-    }
-
-    if (!arg) {
-      return bname;
-    }
-
-    if (((t_base_type*)ttype)->get_base() == t_base_type::TYPE_STRING) {
-      return "const " + bname + "&";
-    } else {
-      return "const " + bname;
-    }
-  }
-
-  // Check for a custom overloaded C++ name
-  if (ttype->is_container()) {
-    string cname;
-
-    t_container* tcontainer = (t_container*)ttype;
-    if (tcontainer->has_cpp_name()) {
-      cname = tcontainer->get_cpp_name();
-    } else if (ttype->is_map()) {
-      t_map* tmap = (t_map*)ttype;
-      cname = "std::map<" + type_name(tmap->get_key_type(), in_typedef) + ", "
-              + type_name(tmap->get_val_type(), in_typedef) + "> ";
-    } else if (ttype->is_set()) {
-      t_set* tset = (t_set*)ttype;
-      cname = "std::set<" + type_name(tset->get_elem_type(), in_typedef) + "> ";
-    } else if (ttype->is_list()) {
-      t_list* tlist = (t_list*)ttype;
-      cname = "std::vector<" + type_name(tlist->get_elem_type(), in_typedef) + "> ";
-    }
-
-    if (arg) {
-      return "const " + cname + "&";
-    } else {
-      return cname;
-    }
-  }
-
-  string class_prefix;
-  if (in_typedef && (ttype->is_struct() || ttype->is_xception())) {
-    class_prefix = "class ";
-  }
-
-  // Check if it needs to be namespaced
-  string pname;
-  t_program* program = ttype->get_program();
-  if (program != NULL && program != program_) {
-    pname = class_prefix + namespace_prefix(program->get_namespace("cpp")) + ttype->get_name();
-  } else {
-    pname = class_prefix + ttype->get_name();
-  }
-
-  if (ttype->is_enum() && !gen_pure_enums_) {
-    pname += "::type";
-  }
-
-  if (arg) {
-    if (is_complex_type(ttype)) {
-      return "const " + pname + "&";
-    } else {
-      return "const " + pname;
-    }
-  } else {
-    return pname;
-  }
-}
-
-/**
- * Returns the C++ type that corresponds to the thrift type.
- *
- * @param tbase The base type
- * @return Explicit C++ type, i.e. "int32_t"
- */
-string t_cpp_generator::base_type_name(t_base_type::t_base tbase) {
-  switch (tbase) {
-  case t_base_type::TYPE_VOID:
-    return "void";
-  case t_base_type::TYPE_STRING:
-    return "std::string";
-  case t_base_type::TYPE_BOOL:
-    return "bool";
-  case t_base_type::TYPE_I8:
-    return "int8_t";
-  case t_base_type::TYPE_I16:
-    return "int16_t";
-  case t_base_type::TYPE_I32:
-    return "int32_t";
-  case t_base_type::TYPE_I64:
-    return "int64_t";
-  case t_base_type::TYPE_DOUBLE:
-    return "double";
-  default:
-    throw "compiler error: no C++ base type name for base type " + t_base_type::t_base_name(tbase);
-  }
-}
-
-/**
- * Declares a field, which may include initialization as necessary.
- *
- * @param ttype The type
- * @return Field declaration, i.e. int x = 0;
- */
-string t_cpp_generator::declare_field(t_field* tfield,
-                                      bool init,
-                                      bool pointer,
-                                      bool constant,
-                                      bool reference) {
-  // TODO(mcslee): do we ever need to initialize the field?
-  string result = "";
-  if (constant) {
-    result += "const ";
-  }
-  result += type_name(tfield->get_type());
-  if (is_reference(tfield)) {
-    result = "::apache::thrift::stdcxx::shared_ptr<" + result + ">";
-  }
-  if (pointer) {
-    result += "*";
-  }
-  if (reference) {
-    result += "&";
-  }
-  result += " " + tfield->get_name();
-  if (init) {
-    t_type* type = get_true_type(tfield->get_type());
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-      case t_base_type::TYPE_STRING:
-        break;
-      case t_base_type::TYPE_BOOL:
-        result += " = false";
-        break;
-      case t_base_type::TYPE_I8:
-      case t_base_type::TYPE_I16:
-      case t_base_type::TYPE_I32:
-      case t_base_type::TYPE_I64:
-        result += " = 0";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        result += " = (double)0";
-        break;
-      default:
-        throw "compiler error: no C++ initializer for base type " + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      result += " = (" + type_name(type) + ")0";
-    }
-  }
-  if (!reference) {
-    result += ";";
-  }
-  return result;
-}
-
-/**
- * Renders a function signature of the form 'type name(args)'
- *
- * @param tfunction Function definition
- * @return String of rendered function definition
- */
-string t_cpp_generator::function_signature(t_function* tfunction,
-                                           string style,
-                                           string prefix,
-                                           bool name_params) {
-  t_type* ttype = tfunction->get_returntype();
-  t_struct* arglist = tfunction->get_arglist();
-  bool has_xceptions = !tfunction->get_xceptions()->get_members().empty();
-
-  if (style == "") {
-    if (is_complex_type(ttype)) {
-      return "void " + prefix + tfunction->get_name() + "(" + type_name(ttype)
-             + (name_params ? "& _return" : "& /* _return */")
-             + argument_list(arglist, name_params, true) + ")";
-    } else {
-      return type_name(ttype) + " " + prefix + tfunction->get_name() + "("
-             + argument_list(arglist, name_params) + ")";
-    }
-  } else if (style.substr(0, 3) == "Cob") {
-    string cob_type;
-    string exn_cob;
-    if (style == "CobCl") {
-      cob_type = "(" + service_name_ + "CobClient";
-      if (gen_templates_) {
-        cob_type += "T<Protocol_>";
-      }
-      cob_type += "* client)";
-    } else if (style == "CobSv") {
-      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 */";
-      }
-    } else {
-      throw "UNKNOWN STYLE";
-    }
-
-    return "void " + prefix + tfunction->get_name() + "(::apache::thrift::stdcxx::function<void" + cob_type + "> cob"
-           + exn_cob + argument_list(arglist, name_params, true) + ")";
-  } else {
-    throw "UNKNOWN STYLE";
-  }
-}
-
-/**
- * Renders a field list
- *
- * @param tstruct The struct definition
- * @return Comma sepearated list of all field names in that struct
- */
-string t_cpp_generator::argument_list(t_struct* tstruct, bool name_params, bool start_comma) {
-  string result = "";
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = !start_comma;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      result += ", ";
-    }
-    result += type_name((*f_iter)->get_type(), false, true) + " "
-              + (name_params ? (*f_iter)->get_name() : "/* " + (*f_iter)->get_name() + " */");
-  }
-  return result;
-}
-
-/**
- * Converts the parse type to a C++ enum string for the given type.
- *
- * @param type Thrift Type
- * @return String of C++ code to definition of that type constant
- */
-string t_cpp_generator::type_to_enum(t_type* type) {
-  type = get_true_type(type);
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "NO T_VOID CONSTRUCT";
-    case t_base_type::TYPE_STRING:
-      return "::apache::thrift::protocol::T_STRING";
-    case t_base_type::TYPE_BOOL:
-      return "::apache::thrift::protocol::T_BOOL";
-    case t_base_type::TYPE_I8:
-      return "::apache::thrift::protocol::T_BYTE";
-    case t_base_type::TYPE_I16:
-      return "::apache::thrift::protocol::T_I16";
-    case t_base_type::TYPE_I32:
-      return "::apache::thrift::protocol::T_I32";
-    case t_base_type::TYPE_I64:
-      return "::apache::thrift::protocol::T_I64";
-    case t_base_type::TYPE_DOUBLE:
-      return "::apache::thrift::protocol::T_DOUBLE";
-    }
-  } else if (type->is_enum()) {
-    return "::apache::thrift::protocol::T_I32";
-  } else if (type->is_struct()) {
-    return "::apache::thrift::protocol::T_STRUCT";
-  } else if (type->is_xception()) {
-    return "::apache::thrift::protocol::T_STRUCT";
-  } else if (type->is_map()) {
-    return "::apache::thrift::protocol::T_MAP";
-  } else if (type->is_set()) {
-    return "::apache::thrift::protocol::T_SET";
-  } else if (type->is_list()) {
-    return "::apache::thrift::protocol::T_LIST";
-  }
-
-  throw "INVALID TYPE IN type_to_enum: " + type->get_name();
-}
-
-string t_cpp_generator::get_include_prefix(const t_program& program) const {
-  string include_prefix = program.get_include_prefix();
-  if (!use_include_prefix_ || (include_prefix.size() > 0 && include_prefix[0] == '/')) {
-    // if flag is turned off or this is absolute path, return empty prefix
-    return "";
-  }
-
-  string::size_type last_slash = string::npos;
-  if ((last_slash = include_prefix.rfind("/")) != string::npos) {
-    return include_prefix.substr(0, last_slash)
-           + (get_program()->is_out_path_absolute() ? "/" : "/" + out_dir_base_ + "/");
-  }
-
-  return "";
-}
-
-THRIFT_REGISTER_GENERATOR(
-    cpp,
-    "C++",
-    "    cob_style:       Generate \"Continuation OBject\"-style classes.\n"
-    "    no_client_completion:\n"
-    "                     Omit calls to completion__() in CobClient class.\n"
-    "    no_default_operators:\n"
-    "                     Omits generation of default operators ==, != and <\n"
-    "    templates:       Generate templatized reader/writer methods.\n"
-    "    pure_enums:      Generate pure enums instead of wrapper classes.\n"
-    "    include_prefix:  Use full include paths in generated files.\n"
-    "    moveable_types:  Generate move constructors and assignment operators.\n"
-    "    no_ostream_operators:\n"
-    "                     Omit generation of ostream definitions.\n"
-    "    no_skeleton:     Omits generation of skeleton.\n")
+/* 
+ * 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. 
+ * 
+ * Contains some contributions under the Thrift Software License. 
+ * Please see doc/old-thrift-license.txt in the Thrift distribution for 
+ * details. 
+ */ 
+ 
+#include <cassert> 
+ 
+#include <fstream> 
+#include <iomanip> 
+#include <iostream> 
+#include <limits> 
+#include <sstream> 
+#include <string> 
+#include <vector> 
+ 
+#include <sys/stat.h> 
+ 
+#include "thrift/platform.h" 
+#include "thrift/generate/t_oop_generator.h" 
+ 
+using std::map; 
+using std::ofstream; 
+using std::ostream; 
+using std::string; 
+using std::vector; 
+ 
+static const string endl = "\n"; // avoid ostream << std::endl flushes 
+ 
+/** 
+ * C++ code generator. This is legitimacy incarnate. 
+ * 
+ */ 
+class t_cpp_generator : public t_oop_generator { 
+public: 
+  t_cpp_generator(t_program* program, 
+                  const std::map<std::string, std::string>& parsed_options, 
+                  const std::string& option_string) 
+    : t_oop_generator(program) { 
+    (void)option_string; 
+    std::map<std::string, std::string>::const_iterator iter; 
+ 
+ 
+    gen_pure_enums_ = false; 
+    use_include_prefix_ = false; 
+    gen_cob_style_ = false; 
+    gen_no_client_completion_ = false; 
+    gen_no_default_operators_ = false; 
+    gen_templates_ = false; 
+    gen_templates_only_ = false; 
+    gen_moveable_ = false; 
+    gen_no_ostream_operators_ = false; 
+    gen_no_skeleton_ = false; 
+ 
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) { 
+      if( iter->first.compare("pure_enums") == 0) { 
+        gen_pure_enums_ = true; 
+      } else if( iter->first.compare("include_prefix") == 0) { 
+        use_include_prefix_ = true; 
+      } else if( iter->first.compare("cob_style") == 0) { 
+        gen_cob_style_ = true; 
+      } else if( iter->first.compare("no_client_completion") == 0) { 
+        gen_no_client_completion_ = true; 
+      } else if( iter->first.compare("no_default_operators") == 0) { 
+        gen_no_default_operators_ = true; 
+      } else if( iter->first.compare("templates") == 0) { 
+        gen_templates_ = true; 
+        gen_templates_only_ = (iter->second == "only"); 
+      } else if( iter->first.compare("moveable_types") == 0) { 
+        gen_moveable_ = true; 
+      } else if ( iter->first.compare("no_ostream_operators") == 0) { 
+        gen_no_ostream_operators_ = true; 
+      } else if ( iter->first.compare("no_skeleton") == 0) { 
+        gen_no_skeleton_ = true; 
+      } else { 
+        throw "unknown option cpp:" + iter->first; 
+      } 
+    } 
+ 
+    out_dir_base_ = "gen-cpp"; 
+  } 
+ 
+  /** 
+   * Init and close methods 
+   */ 
+ 
+  void init_generator(); 
+  void close_generator(); 
+ 
+  void generate_consts(std::vector<t_const*> consts); 
+ 
+  /** 
+   * Program-level generation functions 
+   */ 
+ 
+  void generate_typedef(t_typedef* ttypedef); 
+  void generate_enum(t_enum* tenum); 
+  void generate_enum_ostream_operator_decl(std::ostream& out, t_enum* tenum); 
+  void generate_enum_ostream_operator(std::ostream& out, t_enum* tenum); 
+  void generate_forward_declaration(t_struct* tstruct); 
+  void generate_struct(t_struct* tstruct) { generate_cpp_struct(tstruct, false); } 
+  void generate_xception(t_struct* txception) { generate_cpp_struct(txception, true); } 
+  void generate_cpp_struct(t_struct* tstruct, bool is_exception); 
+ 
+  void generate_service(t_service* tservice); 
+ 
+  void print_const_value(std::ostream& out, std::string name, t_type* type, t_const_value* value); 
+  std::string render_const_value(std::ostream& out, 
+                                 std::string name, 
+                                 t_type* type, 
+                                 t_const_value* value); 
+ 
+  void generate_struct_declaration(std::ostream& out, 
+                                   t_struct* tstruct, 
+                                   bool is_exception = false, 
+                                   bool pointers = false, 
+                                   bool read = true, 
+                                   bool write = true, 
+                                   bool swap = false, 
+                                   bool is_user_struct = false); 
+  void generate_struct_definition(std::ostream& out, 
+                                  std::ostream& force_cpp_out, 
+                                  t_struct* tstruct, 
+                                  bool setters = true, 
+                                  bool is_user_struct = false); 
+  void generate_copy_constructor(std::ostream& out, t_struct* tstruct, bool is_exception); 
+  void generate_move_constructor(std::ostream& out, t_struct* tstruct, bool is_exception); 
+  void generate_constructor_helper(std::ostream& out, 
+                                   t_struct* tstruct, 
+                                   bool is_excpetion, 
+                                   bool is_move); 
+  void generate_assignment_operator(std::ostream& out, t_struct* tstruct); 
+  void generate_move_assignment_operator(std::ostream& out, t_struct* tstruct); 
+  void generate_assignment_helper(std::ostream& out, t_struct* tstruct, bool is_move); 
+  void generate_struct_reader(std::ostream& out, t_struct* tstruct, bool pointers = false); 
+  void generate_struct_writer(std::ostream& out, t_struct* tstruct, bool pointers = false); 
+  void generate_struct_result_writer(std::ostream& out, t_struct* tstruct, bool pointers = false); 
+  void generate_struct_swap(std::ostream& out, t_struct* tstruct); 
+  void generate_struct_print_method(std::ostream& out, t_struct* tstruct); 
+  void generate_exception_what_method(std::ostream& out, t_struct* tstruct); 
+ 
+  /** 
+   * Service-level generation functions 
+   */ 
+ 
+  void generate_service_interface(t_service* tservice, string style); 
+  void generate_service_interface_factory(t_service* tservice, string style); 
+  void generate_service_null(t_service* tservice, string style); 
+  void generate_service_multiface(t_service* tservice); 
+  void generate_service_helpers(t_service* tservice); 
+  void generate_service_client(t_service* tservice, string style); 
+  void generate_service_processor(t_service* tservice, string style); 
+  void generate_service_skeleton(t_service* tservice); 
+  void generate_process_function(t_service* tservice, 
+                                 t_function* tfunction, 
+                                 string style, 
+                                 bool specialized = false); 
+  void generate_function_helpers(t_service* tservice, t_function* tfunction); 
+  void generate_service_async_skeleton(t_service* tservice); 
+ 
+  /** 
+   * Serialization constructs 
+   */ 
+ 
+  void generate_deserialize_field(std::ostream& out, 
+                                  t_field* tfield, 
+                                  std::string prefix = "", 
+                                  std::string suffix = ""); 
+ 
+  void generate_deserialize_struct(std::ostream& out, 
+                                   t_struct* tstruct, 
+                                   std::string prefix = "", 
+                                   bool pointer = false); 
+ 
+  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+ 
+  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = ""); 
+ 
+  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = ""); 
+ 
+  void generate_deserialize_list_element(std::ostream& out, 
+                                         t_list* tlist, 
+                                         std::string prefix, 
+                                         bool push_back, 
+                                         std::string index); 
+ 
+  void generate_serialize_field(std::ostream& out, 
+                                t_field* tfield, 
+                                std::string prefix = "", 
+                                std::string suffix = ""); 
+ 
+  void generate_serialize_struct(std::ostream& out, 
+                                 t_struct* tstruct, 
+                                 std::string prefix = "", 
+                                 bool pointer = false); 
+ 
+  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+ 
+  void generate_serialize_map_element(std::ostream& out, t_map* tmap, std::string iter); 
+ 
+  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter); 
+ 
+  void generate_serialize_list_element(std::ostream& out, t_list* tlist, std::string iter); 
+ 
+  void generate_function_call(ostream& out, 
+                              t_function* tfunction, 
+                              string target, 
+                              string iface, 
+                              string arg_prefix); 
+  /* 
+   * Helper rendering functions 
+   */ 
+ 
+  std::string namespace_prefix(std::string ns); 
+  std::string namespace_open(std::string ns); 
+  std::string namespace_close(std::string ns); 
+  std::string type_name(t_type* ttype, bool in_typedef = false, bool arg = false); 
+  std::string base_type_name(t_base_type::t_base tbase); 
+  std::string declare_field(t_field* tfield, 
+                            bool init = false, 
+                            bool pointer = false, 
+                            bool constant = false, 
+                            bool reference = false); 
+  std::string function_signature(t_function* tfunction, 
+                                 std::string style, 
+                                 std::string prefix = "", 
+                                 bool name_params = true); 
+  std::string cob_function_signature(t_function* tfunction, 
+                                     std::string prefix = "", 
+                                     bool name_params = true); 
+  std::string argument_list(t_struct* tstruct, bool name_params = true, bool start_comma = false); 
+  std::string type_to_enum(t_type* ttype); 
+ 
+  void generate_enum_constant_list(std::ostream& f, 
+                                   const vector<t_enum_value*>& constants, 
+                                   const char* prefix, 
+                                   const char* suffix, 
+                                   bool include_values); 
+ 
+  void generate_struct_ostream_operator_decl(std::ostream& f, t_struct* tstruct); 
+  void generate_struct_ostream_operator(std::ostream& f, t_struct* tstruct); 
+  void generate_struct_print_method_decl(std::ostream& f, t_struct* tstruct); 
+  void generate_exception_what_method_decl(std::ostream& f, 
+                                           t_struct* tstruct, 
+                                           bool external = false); 
+ 
+  bool is_reference(t_field* tfield) { return tfield->get_reference(); } 
+ 
+  bool is_complex_type(t_type* ttype) { 
+    ttype = get_true_type(ttype); 
+ 
+    return ttype->is_container() || ttype->is_struct() || ttype->is_xception() 
+           || (ttype->is_base_type() 
+               && (((t_base_type*)ttype)->get_base() == t_base_type::TYPE_STRING)); 
+  } 
+ 
+  void set_use_include_prefix(bool use_include_prefix) { use_include_prefix_ = use_include_prefix; } 
+ 
+  /** 
+   * The compiler option "no_thrift_ostream_impl" can be used to prevent 
+   * the compiler from emitting implementations for operator <<.  In this 
+   * case the consuming application must provide any needed to build. 
+   * 
+   * To disable this on a per structure bases, one can alternatively set 
+   * the annotation "cpp.customostream" to prevent thrift from emitting an 
+   * operator << (std::ostream&). 
+   * 
+   * See AnnotationTest for validation of this annotation feature. 
+   */ 
+  bool has_custom_ostream(t_type* ttype) const { 
+    return (gen_no_ostream_operators_) || 
+           (ttype->annotations_.find("cpp.customostream") != ttype->annotations_.end()); 
+  } 
+ 
+private: 
+  /** 
+   * Returns the include prefix to use for a file generated by program, or the 
+   * empty string if no include prefix should be used. 
+   */ 
+  std::string get_include_prefix(const t_program& program) const; 
+ 
+  /** 
+   * True if we should generate pure enums for Thrift enums, instead of wrapper classes. 
+   */ 
+  bool gen_pure_enums_; 
+ 
+  /** 
+   * True if we should generate templatized reader/writer methods. 
+   */ 
+  bool gen_templates_; 
+ 
+  /** 
+   * True iff we should generate process function pointers for only templatized 
+   * reader/writer methods. 
+   */ 
+  bool gen_templates_only_; 
+ 
+  /** 
+   * True if we should generate move constructors & assignment operators. 
+   */ 
+  bool gen_moveable_; 
+ 
+  /** 
+   * True if we should generate ostream definitions 
+   */ 
+  bool gen_no_ostream_operators_; 
+ 
+  /** 
+   * True iff we should use a path prefix in our #include statements for other 
+   * thrift-generated header files. 
+   */ 
+  bool use_include_prefix_; 
+ 
+  /** 
+   * True if we should generate "Continuation OBject"-style classes as well. 
+   */ 
+  bool gen_cob_style_; 
+ 
+  /** 
+   * True if we should omit calls to completion__() in CobClient class. 
+   */ 
+  bool gen_no_client_completion_; 
+ 
+  /** 
+   * True if we should omit generating the default opeartors ==, != and <. 
+   */ 
+  bool gen_no_default_operators_; 
+ 
+   /** 
+   * True if we should generate skeleton. 
+   */ 
+  bool gen_no_skeleton_; 
+ 
+  /** 
+   * Strings for namespace, computed once up front then used directly 
+   */ 
+ 
+  std::string ns_open_; 
+  std::string ns_close_; 
+ 
+  /** 
+   * File streams, stored here to avoid passing them as parameters to every 
+   * function. 
+   */ 
+ 
+  ofstream_with_content_based_conditional_update f_types_; 
+  ofstream_with_content_based_conditional_update f_types_impl_; 
+  ofstream_with_content_based_conditional_update f_types_tcc_; 
+  ofstream_with_content_based_conditional_update f_header_; 
+  ofstream_with_content_based_conditional_update f_service_; 
+  ofstream_with_content_based_conditional_update f_service_tcc_; 
+ 
+  // The ProcessorGenerator is used to generate parts of the code, 
+  // so it needs access to many of our protected members and methods. 
+  // 
+  // TODO: The code really should be cleaned up so that helper methods for 
+  // writing to the output files are separate from the generator classes 
+  // themselves. 
+  friend class ProcessorGenerator; 
+}; 
+ 
+/** 
+ * Prepares for file generation by opening up the necessary file output 
+ * streams. 
+ */ 
+void t_cpp_generator::init_generator() { 
+  // Make output directory 
+  MKDIR(get_out_dir().c_str()); 
+ 
+  // Make output file 
+  string f_types_name = get_out_dir() + program_name_ + "_types.h"; 
+  f_types_.open(f_types_name); 
+ 
+  string f_types_impl_name = get_out_dir() + program_name_ + "_types.cpp"; 
+  f_types_impl_.open(f_types_impl_name.c_str()); 
+ 
+  if (gen_templates_) { 
+    // If we don't open the stream, it appears to just discard data, 
+    // which is fine. 
+    string f_types_tcc_name = get_out_dir() + program_name_ + "_types.tcc"; 
+    f_types_tcc_.open(f_types_tcc_name.c_str()); 
+  } 
+ 
+  // Print header 
+  f_types_ << autogen_comment(); 
+  f_types_impl_ << autogen_comment(); 
+  f_types_tcc_ << autogen_comment(); 
+ 
+  // Start ifndef 
+  f_types_ << "#ifndef " << program_name_ << "_TYPES_H" << endl << "#define " << program_name_ 
+           << "_TYPES_H" << endl << endl; 
+  f_types_tcc_ << "#ifndef " << program_name_ << "_TYPES_TCC" << endl << "#define " << program_name_ 
+               << "_TYPES_TCC" << endl << endl; 
+ 
+  // Include base types 
+  f_types_ << "#include <iosfwd>" << endl 
+           << endl 
+           << "#include <thrift/Thrift.h>" << endl 
+           << "#include <thrift/TApplicationException.h>" << endl 
+           << "#include <thrift/TBase.h>" << endl 
+           << "#include <thrift/protocol/TProtocol.h>" << endl 
+           << "#include <thrift/transport/TTransport.h>" << endl 
+           << endl; 
+  // Include C++xx compatibility header 
+  f_types_ << "#include <thrift/stdcxx.h>" << endl; 
+ 
+  // Include other Thrift includes 
+  const vector<t_program*>& includes = program_->get_includes(); 
+  for (size_t i = 0; i < includes.size(); ++i) { 
+    f_types_ << "#include \"" << get_include_prefix(*(includes[i])) << includes[i]->get_name() 
+             << "_types.h\"" << endl; 
+ 
+    // XXX(simpkins): If gen_templates_ is enabled, we currently assume all 
+    // included files were also generated with templates enabled. 
+    f_types_tcc_ << "#include \"" << get_include_prefix(*(includes[i])) << includes[i]->get_name() 
+                 << "_types.tcc\"" << endl; 
+  } 
+  f_types_ << endl; 
+ 
+  // Include custom headers 
+  const vector<string>& cpp_includes = program_->get_cpp_includes(); 
+  for (size_t i = 0; i < cpp_includes.size(); ++i) { 
+    if (cpp_includes[i][0] == '<') { 
+      f_types_ << "#include " << cpp_includes[i] << endl; 
+    } else { 
+      f_types_ << "#include \"" << cpp_includes[i] << "\"" << endl; 
+    } 
+  } 
+  f_types_ << endl; 
+ 
+  // Include the types file 
+  f_types_impl_ << "#include \"" << get_include_prefix(*get_program()) << program_name_ 
+                << "_types.h\"" << endl << endl; 
+  f_types_tcc_ << "#include \"" << get_include_prefix(*get_program()) << program_name_ 
+               << "_types.h\"" << endl << endl; 
+ 
+  // The swap() code needs <algorithm> for std::swap() 
+  f_types_impl_ << "#include <algorithm>" << endl; 
+  // for operator<< 
+  f_types_impl_ << "#include <ostream>" << endl << endl; 
+  f_types_impl_ << "#include <thrift/TToString.h>" << endl << endl; 
+ 
+  // Open namespace 
+  ns_open_ = namespace_open(program_->get_namespace("cpp")); 
+  ns_close_ = namespace_close(program_->get_namespace("cpp")); 
+ 
+  f_types_ << ns_open_ << endl << endl; 
+ 
+  f_types_impl_ << ns_open_ << endl << endl; 
+ 
+  f_types_tcc_ << ns_open_ << endl << endl; 
+} 
+ 
+/** 
+ * Closes the output files. 
+ */ 
+void t_cpp_generator::close_generator() { 
+  // Close namespace 
+  f_types_ << ns_close_ << endl << endl; 
+  f_types_impl_ << ns_close_ << endl; 
+  f_types_tcc_ << ns_close_ << endl << endl; 
+ 
+  // Include the types.tcc file from the types header file, 
+  // so clients don't have to explicitly include the tcc file. 
+  // TODO(simpkins): Make this a separate option. 
+  if (gen_templates_) { 
+    f_types_ << "#include \"" << get_include_prefix(*get_program()) << program_name_ 
+             << "_types.tcc\"" << endl << endl; 
+  } 
+ 
+  // Close ifndef 
+  f_types_ << "#endif" << endl; 
+  f_types_tcc_ << "#endif" << endl; 
+ 
+  // Close output file 
+  f_types_.close(); 
+  f_types_impl_.close(); 
+  f_types_tcc_.close(); 
+} 
+ 
+/** 
+ * Generates a typedef. This is just a simple 1-liner in C++ 
+ * 
+ * @param ttypedef The type definition 
+ */ 
+void t_cpp_generator::generate_typedef(t_typedef* ttypedef) { 
+  f_types_ << indent() << "typedef " << type_name(ttypedef->get_type(), true) << " " 
+           << ttypedef->get_symbolic() << ";" << endl << endl; 
+} 
+ 
+void t_cpp_generator::generate_enum_constant_list(std::ostream& f, 
+                                                  const vector<t_enum_value*>& constants, 
+                                                  const char* prefix, 
+                                                  const char* suffix, 
+                                                  bool include_values) { 
+  f << " {" << endl; 
+  indent_up(); 
+ 
+  vector<t_enum_value*>::const_iterator c_iter; 
+  bool first = true; 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      f << "," << endl; 
+    } 
+    indent(f) << prefix << (*c_iter)->get_name() << suffix; 
+    if (include_values) { 
+      f << " = " << (*c_iter)->get_value(); 
+    } 
+  } 
+ 
+  f << endl; 
+  indent_down(); 
+  indent(f) << "};" << endl; 
+} 
+ 
+/** 
+ * Generates code for an enumerated type. In C++, this is essentially the same 
+ * as the thrift definition itself, using the enum keyword in C++. 
+ * 
+ * @param tenum The enumeration 
+ */ 
+void t_cpp_generator::generate_enum(t_enum* tenum) { 
+  vector<t_enum_value*> constants = tenum->get_constants(); 
+ 
+  std::string enum_name = tenum->get_name(); 
+  if (!gen_pure_enums_) { 
+    enum_name = "type"; 
+    f_types_ << indent() << "struct " << tenum->get_name() << " {" << endl; 
+    indent_up(); 
+  } 
+  f_types_ << indent() << "enum " << enum_name; 
+ 
+  generate_enum_constant_list(f_types_, constants, "", "", true); 
+ 
+  if (!gen_pure_enums_) { 
+    indent_down(); 
+    f_types_ << "};" << endl; 
+  } 
+ 
+  f_types_ << endl; 
+ 
+  /** 
+     Generate a character array of enum names for debugging purposes. 
+  */ 
+  std::string prefix = ""; 
+  if (!gen_pure_enums_) { 
+    prefix = tenum->get_name() + "::"; 
+  } 
+ 
+  f_types_impl_ << indent() << "int _k" << tenum->get_name() << "Values[] ="; 
+  generate_enum_constant_list(f_types_impl_, constants, prefix.c_str(), "", false); 
+ 
+  f_types_impl_ << indent() << "const char* _k" << tenum->get_name() << "Names[] ="; 
+  generate_enum_constant_list(f_types_impl_, constants, "\"", "\"", false); 
+ 
+  f_types_ << indent() << "extern const std::map<int, const char*> _" << tenum->get_name() 
+           << "_VALUES_TO_NAMES;" << endl << endl; 
+ 
+  f_types_impl_ << indent() << "const std::map<int, const char*> _" << tenum->get_name() 
+                << "_VALUES_TO_NAMES(::apache::thrift::TEnumIterator(" << constants.size() << ", _k" 
+                << tenum->get_name() << "Values" 
+                << ", _k" << tenum->get_name() << "Names), " 
+                << "::apache::thrift::TEnumIterator(-1, NULL, NULL));" << endl << endl; 
+ 
+  generate_enum_ostream_operator_decl(f_types_, tenum); 
+  generate_enum_ostream_operator(f_types_impl_, tenum); 
+} 
+ 
+void t_cpp_generator::generate_enum_ostream_operator_decl(std::ostream& out, t_enum* tenum) { 
+ 
+  out << "std::ostream& operator<<(std::ostream& out, const "; 
+  if (gen_pure_enums_) { 
+    out << tenum->get_name(); 
+  } else { 
+    out << tenum->get_name() << "::type&"; 
+  } 
+  out << " val);" << endl; 
+  out << endl; 
+} 
+ 
+void t_cpp_generator::generate_enum_ostream_operator(std::ostream& out, t_enum* tenum) { 
+ 
+  // If we've been told the consuming application will provide an ostream 
+  // operator definition then we only make a declaration: 
+ 
+  if (!has_custom_ostream(tenum)) { 
+    out << "std::ostream& operator<<(std::ostream& out, const "; 
+    if (gen_pure_enums_) { 
+      out << tenum->get_name(); 
+    } else { 
+      out << tenum->get_name() << "::type&"; 
+    } 
+    out << " val) "; 
+    scope_up(out); 
+ 
+    out << indent() << "std::map<int, const char*>::const_iterator it = _" 
+             << tenum->get_name() << "_VALUES_TO_NAMES.find(val);" << endl; 
+    out << indent() << "if (it != _" << tenum->get_name() << "_VALUES_TO_NAMES.end()) {" << endl; 
+    indent_up(); 
+    out << indent() << "out << it->second;" << endl; 
+    indent_down(); 
+    out << indent() << "} else {" << endl; 
+    indent_up(); 
+    out << indent() << "out << static_cast<int>(val);" << endl; 
+    indent_down(); 
+    out << indent() << "}" << endl; 
+ 
+    out << indent() << "return out;" << endl; 
+    scope_down(out); 
+    out << endl; 
+  } 
+} 
+ 
+/** 
+ * Generates a class that holds all the constants. 
+ */ 
+void t_cpp_generator::generate_consts(std::vector<t_const*> consts) { 
+  string f_consts_name = get_out_dir() + program_name_ + "_constants.h"; 
+  ofstream_with_content_based_conditional_update f_consts; 
+  f_consts.open(f_consts_name); 
+ 
+  string f_consts_impl_name = get_out_dir() + program_name_ + "_constants.cpp"; 
+  ofstream_with_content_based_conditional_update f_consts_impl; 
+  f_consts_impl.open(f_consts_impl_name); 
+ 
+  // Print header 
+  f_consts << autogen_comment(); 
+  f_consts_impl << autogen_comment(); 
+ 
+  // Start ifndef 
+  f_consts << "#ifndef " << program_name_ << "_CONSTANTS_H" << endl << "#define " << program_name_ 
+           << "_CONSTANTS_H" << endl << endl << "#include \"" << get_include_prefix(*get_program()) 
+           << program_name_ << "_types.h\"" << endl << endl << ns_open_ << endl << endl; 
+ 
+  f_consts_impl << "#include \"" << get_include_prefix(*get_program()) << program_name_ 
+                << "_constants.h\"" << endl << endl << ns_open_ << endl << endl; 
+ 
+  f_consts << "class " << program_name_ << "Constants {" << endl << " public:" << endl << "  " 
+           << program_name_ << "Constants();" << endl << endl; 
+  indent_up(); 
+  vector<t_const*>::iterator c_iter; 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    string name = (*c_iter)->get_name(); 
+    t_type* type = (*c_iter)->get_type(); 
+    f_consts << indent() << type_name(type) << " " << name << ";" << endl; 
+  } 
+  indent_down(); 
+  f_consts << "};" << endl; 
+ 
+  f_consts_impl << "const " << program_name_ << "Constants g_" << program_name_ << "_constants;" 
+                << endl << endl << program_name_ << "Constants::" << program_name_ 
+                << "Constants() {" << endl; 
+  indent_up(); 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    print_const_value(f_consts_impl, 
+                      (*c_iter)->get_name(), 
+                      (*c_iter)->get_type(), 
+                      (*c_iter)->get_value()); 
+  } 
+  indent_down(); 
+  indent(f_consts_impl) << "}" << endl; 
+ 
+  f_consts << endl << "extern const " << program_name_ << "Constants g_" << program_name_ 
+           << "_constants;" << endl << endl << ns_close_ << endl << endl << "#endif" << endl; 
+  f_consts.close(); 
+ 
+  f_consts_impl << endl << ns_close_ << endl << endl; 
+  f_consts_impl.close(); 
+} 
+ 
+/** 
+ * Prints the value of a constant with the given type. Note that type checking 
+ * is NOT performed in this function as it is always run beforehand using the 
+ * validate_types method in main.cc 
+ */ 
+void t_cpp_generator::print_const_value(ostream& out, 
+                                        string name, 
+                                        t_type* type, 
+                                        t_const_value* value) { 
+  type = get_true_type(type); 
+  if (type->is_base_type()) { 
+    string v2 = render_const_value(out, name, type, value); 
+    indent(out) << name << " = " << v2 << ";" << endl << endl; 
+  } else if (type->is_enum()) { 
+    indent(out) << name << " = (" << type_name(type) << ")" << value->get_integer() << ";" << endl 
+                << endl; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    const vector<t_field*>& fields = ((t_struct*)type)->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    bool is_nonrequired_field = false; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      t_type* field_type = NULL; 
+      is_nonrequired_field = false; 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field_type = (*f_iter)->get_type(); 
+          is_nonrequired_field = (*f_iter)->get_req() != t_field::T_REQUIRED; 
+        } 
+      } 
+      if (field_type == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string(); 
+      } 
+      string val = render_const_value(out, name, field_type, v_iter->second); 
+      indent(out) << name << "." << v_iter->first->get_string() << " = " << val << ";" << endl; 
+      if (is_nonrequired_field) { 
+        indent(out) << name << ".__isset." << v_iter->first->get_string() << " = true;" << endl; 
+      } 
+    } 
+    out << endl; 
+  } else if (type->is_map()) { 
+    t_type* ktype = ((t_map*)type)->get_key_type(); 
+    t_type* vtype = ((t_map*)type)->get_val_type(); 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string key = render_const_value(out, name, ktype, v_iter->first); 
+      string val = render_const_value(out, name, vtype, v_iter->second); 
+      indent(out) << name << ".insert(std::make_pair(" << key << ", " << val << "));" << endl; 
+    } 
+    out << endl; 
+  } else if (type->is_list()) { 
+    t_type* etype = ((t_list*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string val = render_const_value(out, name, etype, *v_iter); 
+      indent(out) << name << ".push_back(" << val << ");" << endl; 
+    } 
+    out << endl; 
+  } else if (type->is_set()) { 
+    t_type* etype = ((t_set*)type)->get_elem_type(); 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string val = render_const_value(out, name, etype, *v_iter); 
+      indent(out) << name << ".insert(" << val << ");" << endl; 
+    } 
+    out << endl; 
+  } else { 
+    throw "INVALID TYPE IN print_const_value: " + type->get_name(); 
+  } 
+} 
+ 
+/** 
+ * 
+ */ 
+string t_cpp_generator::render_const_value(ostream& out, 
+                                           string name, 
+                                           t_type* type, 
+                                           t_const_value* value) { 
+  (void)name; 
+  std::ostringstream render; 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      render << '"' << get_escaped_string(value) << '"'; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      render << ((value->get_integer() > 0) ? "true" : "false"); 
+      break; 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+      render << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_I64: 
+      render << value->get_integer() << "LL"; 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      if (value->get_type() == t_const_value::CV_INTEGER) { 
+        render << "static_cast<double>(" << value->get_integer() << ")"; 
+      } else { 
+        render << emit_double_as_string(value->get_double()); 
+      } 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else if (type->is_enum()) { 
+    render << "(" << type_name(type) << ")" << value->get_integer(); 
+  } else { 
+    string t = tmp("tmp"); 
+    indent(out) << type_name(type) << " " << t << ";" << endl; 
+    print_const_value(out, t, type, value); 
+    render << t; 
+  } 
+ 
+  return render.str(); 
+} 
+ 
+void t_cpp_generator::generate_forward_declaration(t_struct* tstruct) { 
+  // Forward declare struct def 
+  f_types_ << indent() << "class " << tstruct->get_name() << ";" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a struct definition for a thrift data type. This is a class 
+ * with data members and a read/write() function, plus a mirroring isset 
+ * inner class. 
+ * 
+ * @param tstruct The struct definition 
+ */ 
+void t_cpp_generator::generate_cpp_struct(t_struct* tstruct, bool is_exception) { 
+  generate_struct_declaration(f_types_, tstruct, is_exception, false, true, true, true, true); 
+  generate_struct_definition(f_types_impl_, f_types_impl_, tstruct, true, true); 
+ 
+  std::ostream& out = (gen_templates_ ? f_types_tcc_ : f_types_impl_); 
+  generate_struct_reader(out, tstruct); 
+  generate_struct_writer(out, tstruct); 
+  generate_struct_swap(f_types_impl_, tstruct); 
+  generate_copy_constructor(f_types_impl_, tstruct, is_exception); 
+  if (gen_moveable_) { 
+    generate_move_constructor(f_types_impl_, tstruct, is_exception); 
+  } 
+  generate_assignment_operator(f_types_impl_, tstruct); 
+  if (gen_moveable_) { 
+    generate_move_assignment_operator(f_types_impl_, tstruct); 
+  } 
+ 
+  if (!has_custom_ostream(tstruct)) { 
+    generate_struct_print_method(f_types_impl_, tstruct); 
+  } 
+ 
+  if (is_exception) { 
+    generate_exception_what_method(f_types_impl_, tstruct); 
+  } 
+} 
+ 
+void t_cpp_generator::generate_copy_constructor(ostream& out, 
+                                                t_struct* tstruct, 
+                                                bool is_exception) { 
+  generate_constructor_helper(out, tstruct, is_exception, /*is_move=*/false); 
+} 
+ 
+void t_cpp_generator::generate_move_constructor(ostream& out, 
+                                                t_struct* tstruct, 
+                                                bool is_exception) { 
+  generate_constructor_helper(out, tstruct, is_exception, /*is_move=*/true); 
+} 
+ 
+namespace { 
+// Helper to convert a variable to rvalue, if move is enabled 
+std::string maybeMove(std::string const& other, bool move) { 
+  if (move) { 
+    return "std::move(" + other + ")"; 
+  } 
+  return other; 
+} 
+} 
+ 
+void t_cpp_generator::generate_constructor_helper(ostream& out, 
+                                                  t_struct* tstruct, 
+                                                  bool is_exception, 
+                                                  bool is_move) { 
+ 
+  std::string tmp_name = tmp("other"); 
+ 
+  indent(out) << tstruct->get_name() << "::" << tstruct->get_name(); 
+ 
+  if (is_move) { 
+    out << "( " << tstruct->get_name() << "&& "; 
+  } else { 
+    out << "(const " << tstruct->get_name() << "& "; 
+  } 
+  out << tmp_name << ") "; 
+  if (is_exception) 
+    out << ": TException() "; 
+  out << "{" << endl; 
+  indent_up(); 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+ 
+  // eliminate compiler unused warning 
+  if (members.empty()) 
+    indent(out) << "(void) " << tmp_name << ";" << endl; 
+ 
+  vector<t_field*>::const_iterator f_iter; 
+  bool has_nonrequired_fields = false; 
+  for (f_iter = members.begin(); f_iter != members.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() != t_field::T_REQUIRED) 
+      has_nonrequired_fields = true; 
+    indent(out) << (*f_iter)->get_name() << " = " 
+                << maybeMove(tmp_name + "." + (*f_iter)->get_name(), is_move) << ";" << endl; 
+  } 
+ 
+  if (has_nonrequired_fields) { 
+    indent(out) << "__isset = " << maybeMove(tmp_name + ".__isset", is_move) << ";" << endl; 
+  } 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+} 
+ 
+void t_cpp_generator::generate_assignment_operator(ostream& out, t_struct* tstruct) { 
+  generate_assignment_helper(out, tstruct, /*is_move=*/false); 
+} 
+ 
+void t_cpp_generator::generate_move_assignment_operator(ostream& out, t_struct* tstruct) { 
+  generate_assignment_helper(out, tstruct, /*is_move=*/true); 
+} 
+ 
+void t_cpp_generator::generate_assignment_helper(ostream& out, t_struct* tstruct, bool is_move) { 
+  std::string tmp_name = tmp("other"); 
+ 
+  indent(out) << tstruct->get_name() << "& " << tstruct->get_name() << "::operator=("; 
+ 
+  if (is_move) { 
+    out << tstruct->get_name() << "&& "; 
+  } else { 
+    out << "const " << tstruct->get_name() << "& "; 
+  } 
+  out << tmp_name << ") {" << endl; 
+ 
+  indent_up(); 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+ 
+  // eliminate compiler unused warning 
+  if (members.empty()) 
+    indent(out) << "(void) " << tmp_name << ";" << endl; 
+ 
+  vector<t_field*>::const_iterator f_iter; 
+  bool has_nonrequired_fields = false; 
+  for (f_iter = members.begin(); f_iter != members.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() != t_field::T_REQUIRED) 
+      has_nonrequired_fields = true; 
+    indent(out) << (*f_iter)->get_name() << " = " 
+                << maybeMove(tmp_name + "." + (*f_iter)->get_name(), is_move) << ";" << endl; 
+  } 
+  if (has_nonrequired_fields) { 
+    indent(out) << "__isset = " << maybeMove(tmp_name + ".__isset", is_move) << ";" << endl; 
+  } 
+ 
+  indent(out) << "return *this;" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+} 
+ 
+/** 
+ * Writes the struct declaration into the header file 
+ * 
+ * @param out Output stream 
+ * @param tstruct The struct 
+ */ 
+void t_cpp_generator::generate_struct_declaration(ostream& out, 
+                                                  t_struct* tstruct, 
+                                                  bool is_exception, 
+                                                  bool pointers, 
+                                                  bool read, 
+                                                  bool write, 
+                                                  bool swap, 
+                                                  bool is_user_struct) { 
+  string extends = ""; 
+  if (is_exception) { 
+    extends = " : public ::apache::thrift::TException"; 
+  } else { 
+    if (is_user_struct && !gen_templates_) { 
+      extends = " : public virtual ::apache::thrift::TBase"; 
+    } 
+  } 
+ 
+  // Get members 
+  vector<t_field*>::const_iterator m_iter; 
+  const vector<t_field*>& members = tstruct->get_members(); 
+ 
+  // Write the isset structure declaration outside the class. This makes 
+  // the generated code amenable to processing by SWIG. 
+  // We only declare the struct if it gets used in the class. 
+ 
+  // Isset struct has boolean fields, but only for non-required fields. 
+  bool has_nonrequired_fields = false; 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    if ((*m_iter)->get_req() != t_field::T_REQUIRED) 
+      has_nonrequired_fields = true; 
+  } 
+ 
+  if (has_nonrequired_fields && (!pointers || read)) { 
+ 
+    out << indent() << "typedef struct _" << tstruct->get_name() << "__isset {" << endl; 
+    indent_up(); 
+ 
+    indent(out) << "_" << tstruct->get_name() << "__isset() "; 
+    bool first = true; 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      if ((*m_iter)->get_req() == t_field::T_REQUIRED) { 
+        continue; 
+      } 
+      string isSet = ((*m_iter)->get_value() != NULL) ? "true" : "false"; 
+      if (first) { 
+        first = false; 
+        out << ": " << (*m_iter)->get_name() << "(" << isSet << ")"; 
+      } else { 
+        out << ", " << (*m_iter)->get_name() << "(" << isSet << ")"; 
+      } 
+    } 
+    out << " {}" << endl; 
+ 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      if ((*m_iter)->get_req() != t_field::T_REQUIRED) { 
+        indent(out) << "bool " << (*m_iter)->get_name() << " :1;" << endl; 
+      } 
+    } 
+ 
+    indent_down(); 
+    indent(out) << "} _" << tstruct->get_name() << "__isset;" << endl; 
+  } 
+ 
+  out << endl; 
+ 
+  // Open struct def 
+  out << indent() << "class " << tstruct->get_name() << extends << " {" << endl << indent() 
+      << " public:" << endl << endl; 
+  indent_up(); 
+ 
+  if (!pointers) { 
+    // Copy constructor 
+    indent(out) << tstruct->get_name() << "(const " << tstruct->get_name() << "&);" << endl; 
+ 
+    // Move constructor 
+    if (gen_moveable_) { 
+      indent(out) << tstruct->get_name() << "(" << tstruct->get_name() << "&&);" << endl; 
+    } 
+ 
+    // Assignment Operator 
+    indent(out) << tstruct->get_name() << "& operator=(const " << tstruct->get_name() << "&);" 
+                << endl; 
+ 
+    // Move assignment operator 
+    if (gen_moveable_) { 
+      indent(out) << tstruct->get_name() << "& operator=(" << tstruct->get_name() << "&&);" << endl; 
+    } 
+ 
+    // Default constructor 
+    indent(out) << tstruct->get_name() << "()"; 
+ 
+    bool init_ctor = false; 
+ 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      t_type* t = get_true_type((*m_iter)->get_type()); 
+      if (t->is_base_type() || t->is_enum() || is_reference(*m_iter)) { 
+        string dval; 
+        if (t->is_enum()) { 
+          dval += "(" + type_name(t) + ")"; 
+        } 
+        dval += (t->is_string() || is_reference(*m_iter)) ? "" : "0"; 
+        t_const_value* cv = (*m_iter)->get_value(); 
+        if (cv != NULL) { 
+          dval = render_const_value(out, (*m_iter)->get_name(), t, cv); 
+        } 
+        if (!init_ctor) { 
+          init_ctor = true; 
+          out << " : "; 
+          out << (*m_iter)->get_name() << "(" << dval << ")"; 
+        } else { 
+          out << ", " << (*m_iter)->get_name() << "(" << dval << ")"; 
+        } 
+      } 
+    } 
+    out << " {" << endl; 
+    indent_up(); 
+    // TODO(dreiss): When everything else in Thrift is perfect, 
+    // do more of these in the initializer list. 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      t_type* t = get_true_type((*m_iter)->get_type()); 
+ 
+      if (!t->is_base_type()) { 
+        t_const_value* cv = (*m_iter)->get_value(); 
+        if (cv != NULL) { 
+          print_const_value(out, (*m_iter)->get_name(), t, cv); 
+        } 
+      } 
+    } 
+    scope_down(out); 
+  } 
+ 
+  if (tstruct->annotations_.find("final") == tstruct->annotations_.end()) { 
+    out << endl << indent() << "virtual ~" << tstruct->get_name() << "() throw();" << endl; 
+  } 
+ 
+  // Declare all fields 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    indent(out) << declare_field(*m_iter, 
+                                 false, 
+                                 (pointers && !(*m_iter)->get_type()->is_xception()), 
+                                 !read) << endl; 
+  } 
+ 
+  // Add the __isset data member if we need it, using the definition from above 
+  if (has_nonrequired_fields && (!pointers || read)) { 
+    out << endl << indent() << "_" << tstruct->get_name() << "__isset __isset;" << endl; 
+  } 
+ 
+  // Create a setter function for each field 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    if (pointers) { 
+      continue; 
+    } 
+    if (is_reference((*m_iter))) { 
+      out << endl << indent() << "void __set_" << (*m_iter)->get_name() << "(::apache::thrift::stdcxx::shared_ptr<" 
+          << type_name((*m_iter)->get_type(), false, false) << ">"; 
+      out << " val);" << endl; 
+    } else { 
+      out << endl << indent() << "void __set_" << (*m_iter)->get_name() << "(" 
+          << type_name((*m_iter)->get_type(), false, true); 
+      out << " val);" << endl; 
+    } 
+  } 
+  out << endl; 
+ 
+  if (!pointers) { 
+    // Should we generate default operators? 
+    if (!gen_no_default_operators_) { 
+      // Generate an equality testing operator.  Make it inline since the compiler 
+      // will do a better job than we would when deciding whether to inline it. 
+      out << indent() << "bool operator == (const " << tstruct->get_name() << " & " 
+          << (members.size() > 0 ? "rhs" : "/* rhs */") << ") const" << endl; 
+      scope_up(out); 
+      for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+        // Most existing Thrift code does not use isset or optional/required, 
+        // so we treat "default" fields as required. 
+        if ((*m_iter)->get_req() != t_field::T_OPTIONAL) { 
+          out << indent() << "if (!(" << (*m_iter)->get_name() << " == rhs." 
+              << (*m_iter)->get_name() << "))" << endl << indent() << "  return false;" << endl; 
+        } else { 
+          out << indent() << "if (__isset." << (*m_iter)->get_name() << " != rhs.__isset." 
+              << (*m_iter)->get_name() << ")" << endl << indent() << "  return false;" << endl 
+              << indent() << "else if (__isset." << (*m_iter)->get_name() << " && !(" 
+              << (*m_iter)->get_name() << " == rhs." << (*m_iter)->get_name() << "))" << endl 
+              << indent() << "  return false;" << endl; 
+        } 
+      } 
+      indent(out) << "return true;" << endl; 
+      scope_down(out); 
+      out << indent() << "bool operator != (const " << tstruct->get_name() << " &rhs) const {" 
+          << endl << indent() << "  return !(*this == rhs);" << endl << indent() << "}" << endl 
+          << endl; 
+ 
+      // Generate the declaration of a less-than operator.  This must be 
+      // implemented by the application developer if they wish to use it.  (They 
+      // will get a link error if they try to use it without an implementation.) 
+      out << indent() << "bool operator < (const " << tstruct->get_name() << " & ) const;" << endl 
+          << endl; 
+    } 
+  } 
+ 
+  if (read) { 
+    if (gen_templates_) { 
+      out << indent() << "template <class Protocol_>" << endl << indent() 
+          << "uint32_t read(Protocol_* iprot);" << endl; 
+    } else { 
+      out << indent() << "uint32_t read(" 
+          << "::apache::thrift::protocol::TProtocol* iprot);" << endl; 
+    } 
+  } 
+  if (write) { 
+    if (gen_templates_) { 
+      out << indent() << "template <class Protocol_>" << endl << indent() 
+          << "uint32_t write(Protocol_* oprot) const;" << endl; 
+    } else { 
+      out << indent() << "uint32_t write(" 
+          << "::apache::thrift::protocol::TProtocol* oprot) const;" << endl; 
+    } 
+  } 
+  out << endl; 
+ 
+  if (is_user_struct && !has_custom_ostream(tstruct)) { 
+    out << indent() << "virtual "; 
+    generate_struct_print_method_decl(out, NULL); 
+    out << ";" << endl; 
+  } 
+ 
+  // std::exception::what() 
+  if (is_exception) { 
+    out << indent() << "mutable std::string thriftTExceptionMessageHolder_;" << endl; 
+    out << indent(); 
+    generate_exception_what_method_decl(out, tstruct, false); 
+    out << ";" << endl; 
+  } 
+ 
+  indent_down(); 
+  indent(out) << "};" << endl << endl; 
+ 
+  if (swap) { 
+    // Generate a namespace-scope swap() function 
+    out << indent() << "void swap(" << tstruct->get_name() << " &a, " << tstruct->get_name() 
+        << " &b);" << endl << endl; 
+  } 
+ 
+  if (is_user_struct) { 
+    generate_struct_ostream_operator_decl(out, tstruct); 
+  } 
+} 
+ 
+void t_cpp_generator::generate_struct_definition(ostream& out, 
+                                                 ostream& force_cpp_out, 
+                                                 t_struct* tstruct, 
+                                                 bool setters, 
+                                                 bool is_user_struct) { 
+  // Get members 
+  vector<t_field*>::const_iterator m_iter; 
+  const vector<t_field*>& members = tstruct->get_members(); 
+ 
+  // Destructor 
+  if (tstruct->annotations_.find("final") == tstruct->annotations_.end()) { 
+    force_cpp_out << endl << indent() << tstruct->get_name() << "::~" << tstruct->get_name() 
+                  << "() throw() {" << endl; 
+    indent_up(); 
+ 
+    indent_down(); 
+    force_cpp_out << indent() << "}" << endl << endl; 
+  } 
+ 
+  // Create a setter function for each field 
+  if (setters) { 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      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<" 
+            << type_name((*m_iter)->get_type(), false, false) << ">"; 
+        out << " val) {" << endl; 
+      } else { 
+        out << endl << indent() << "void " << tstruct->get_name() << "::__set_" 
+            << (*m_iter)->get_name() << "(" << type_name((*m_iter)->get_type(), false, true); 
+        out << " val) {" << endl; 
+      } 
+      indent_up(); 
+      out << indent() << "this->" << (*m_iter)->get_name() << " = val;" << endl; 
+      indent_down(); 
+ 
+      // assume all fields are required except optional fields. 
+      // for optional fields change __isset.name to true 
+      bool is_optional = (*m_iter)->get_req() == t_field::T_OPTIONAL; 
+      if (is_optional) { 
+        out << indent() << indent() << "__isset." << (*m_iter)->get_name() << " = true;" << endl; 
+      } 
+      out << indent() << "}" << endl; 
+    } 
+  } 
+  if (is_user_struct) { 
+    generate_struct_ostream_operator(out, tstruct); 
+  } 
+  out << endl; 
+} 
+ 
+/** 
+ * Makes a helper function to gen a struct reader. 
+ * 
+ * @param out Stream to write to 
+ * @param tstruct The struct 
+ */ 
+void t_cpp_generator::generate_struct_reader(ostream& out, t_struct* tstruct, bool pointers) { 
+  if (gen_templates_) { 
+    out << indent() << "template <class Protocol_>" << endl << indent() << "uint32_t " 
+        << tstruct->get_name() << "::read(Protocol_* iprot) {" << endl; 
+  } else { 
+    indent(out) << "uint32_t " << tstruct->get_name() 
+                << "::read(::apache::thrift::protocol::TProtocol* iprot) {" << endl; 
+  } 
+  indent_up(); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  // Declare stack tmp variables 
+  out << endl 
+      << indent() << "::apache::thrift::protocol::TInputRecursionTracker tracker(*iprot);" << endl 
+      << indent() << "uint32_t xfer = 0;" << endl 
+      << indent() << "std::string fname;" << endl 
+      << indent() << "::apache::thrift::protocol::TType ftype;" << endl 
+      << indent() << "int16_t fid;" << endl 
+      << endl 
+      << indent() << "xfer += iprot->readStructBegin(fname);" << endl 
+      << endl 
+      << indent() << "using ::apache::thrift::protocol::TProtocolException;" << endl 
+      << endl; 
+ 
+  // Required variables aren't in __isset, so we need tmp vars to check them. 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() == t_field::T_REQUIRED) 
+      indent(out) << "bool isset_" << (*f_iter)->get_name() << " = false;" << endl; 
+  } 
+  out << endl; 
+ 
+  // Loop over reading in fields 
+  indent(out) << "while (true)" << endl; 
+  scope_up(out); 
+ 
+  // Read beginning field marker 
+  indent(out) << "xfer += iprot->readFieldBegin(fname, ftype, fid);" << endl; 
+ 
+  // Check for field STOP marker 
+  out << indent() << "if (ftype == ::apache::thrift::protocol::T_STOP) {" << endl << indent() 
+      << "  break;" << endl << indent() << "}" << endl; 
+ 
+  if (fields.empty()) { 
+    out << indent() << "xfer += iprot->skip(ftype);" << endl; 
+  } else { 
+    // Switch statement on the field we are reading 
+    indent(out) << "switch (fid)" << endl; 
+ 
+    scope_up(out); 
+ 
+    // Generate deserialization code for known cases 
+    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+      indent(out) << "case " << (*f_iter)->get_key() << ":" << endl; 
+      indent_up(); 
+      indent(out) << "if (ftype == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl; 
+      indent_up(); 
+ 
+      const char* isset_prefix = ((*f_iter)->get_req() != t_field::T_REQUIRED) ? "this->__isset." 
+                                                                               : "isset_"; 
+ 
+#if 0 
+          // This code throws an exception if the same field is encountered twice. 
+          // We've decided to leave it out for performance reasons. 
+          // TODO(dreiss): Generate this code and "if" it out to make it easier 
+          // for people recompiling thrift to include it. 
+          out << 
+            indent() << "if (" << isset_prefix << (*f_iter)->get_name() << ")" << endl << 
+            indent() << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl; 
+#endif 
+ 
+      if (pointers && !(*f_iter)->get_type()->is_xception()) { 
+        generate_deserialize_field(out, *f_iter, "(*(this->", "))"); 
+      } else { 
+        generate_deserialize_field(out, *f_iter, "this->"); 
+      } 
+      out << indent() << isset_prefix << (*f_iter)->get_name() << " = true;" << endl; 
+      indent_down(); 
+      out << indent() << "} else {" << endl << indent() << "  xfer += iprot->skip(ftype);" << endl 
+          << 
+          // TODO(dreiss): Make this an option when thrift structs 
+          // have a common base class. 
+          // indent() << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl << 
+          indent() << "}" << endl << indent() << "break;" << endl; 
+      indent_down(); 
+    } 
+ 
+    // In the default case we skip the field 
+    out << indent() << "default:" << endl << indent() << "  xfer += iprot->skip(ftype);" << endl 
+        << indent() << "  break;" << endl; 
+ 
+    scope_down(out); 
+  } //!fields.empty() 
+  // Read field end marker 
+  indent(out) << "xfer += iprot->readFieldEnd();" << endl; 
+ 
+  scope_down(out); 
+ 
+  out << endl << indent() << "xfer += iprot->readStructEnd();" << endl; 
+ 
+  // Throw if any required fields are missing. 
+  // We do this after reading the struct end so that 
+  // there might possibly be a chance of continuing. 
+  out << endl; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if ((*f_iter)->get_req() == t_field::T_REQUIRED) 
+      out << indent() << "if (!isset_" << (*f_iter)->get_name() << ')' << endl << indent() 
+          << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl; 
+  } 
+ 
+  indent(out) << "return xfer;" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates the write function. 
+ * 
+ * @param out Stream to write to 
+ * @param tstruct The struct 
+ */ 
+void t_cpp_generator::generate_struct_writer(ostream& out, t_struct* tstruct, bool pointers) { 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_sorted_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  if (gen_templates_) { 
+    out << indent() << "template <class Protocol_>" << endl << indent() << "uint32_t " 
+        << tstruct->get_name() << "::write(Protocol_* oprot) const {" << endl; 
+  } else { 
+    indent(out) << "uint32_t " << tstruct->get_name() 
+                << "::write(::apache::thrift::protocol::TProtocol* oprot) const {" << endl; 
+  } 
+  indent_up(); 
+ 
+  out << indent() << "uint32_t xfer = 0;" << endl; 
+ 
+  indent(out) << "::apache::thrift::protocol::TOutputRecursionTracker tracker(*oprot);" << endl; 
+  indent(out) << "xfer += oprot->writeStructBegin(\"" << name << "\");" << endl; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    bool check_if_set = (*f_iter)->get_req() == t_field::T_OPTIONAL 
+                        || (*f_iter)->get_type()->is_xception(); 
+    if (check_if_set) { 
+      out << endl << indent() << "if (this->__isset." << (*f_iter)->get_name() << ") {" << endl; 
+      indent_up(); 
+    } else { 
+      out << endl; 
+    } 
+ 
+    // Write field header 
+    out << indent() << "xfer += oprot->writeFieldBegin(" 
+        << "\"" << (*f_iter)->get_name() << "\", " << type_to_enum((*f_iter)->get_type()) << ", " 
+        << (*f_iter)->get_key() << ");" << endl; 
+    // Write field contents 
+    if (pointers && !(*f_iter)->get_type()->is_xception()) { 
+      generate_serialize_field(out, *f_iter, "(*(this->", "))"); 
+    } else { 
+      generate_serialize_field(out, *f_iter, "this->"); 
+    } 
+    // Write field closer 
+    indent(out) << "xfer += oprot->writeFieldEnd();" << endl; 
+    if (check_if_set) { 
+      indent_down(); 
+      indent(out) << '}'; 
+    } 
+  } 
+ 
+  out << endl; 
+ 
+  // Write the struct map 
+  out << indent() << "xfer += oprot->writeFieldStop();" << endl << indent() 
+      << "xfer += oprot->writeStructEnd();" << endl << indent() 
+      << "return xfer;" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Struct writer for result of a function, which can have only one of its 
+ * fields set and does a conditional if else look up into the __isset field 
+ * of the struct. 
+ * 
+ * @param out Output stream 
+ * @param tstruct The result struct 
+ */ 
+void t_cpp_generator::generate_struct_result_writer(ostream& out, 
+                                                    t_struct* tstruct, 
+                                                    bool pointers) { 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_sorted_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  if (gen_templates_) { 
+    out << indent() << "template <class Protocol_>" << endl << indent() << "uint32_t " 
+        << tstruct->get_name() << "::write(Protocol_* oprot) const {" << endl; 
+  } else { 
+    indent(out) << "uint32_t " << tstruct->get_name() 
+                << "::write(::apache::thrift::protocol::TProtocol* oprot) const {" << endl; 
+  } 
+  indent_up(); 
+ 
+  out << endl << indent() << "uint32_t xfer = 0;" << endl << endl; 
+ 
+  indent(out) << "xfer += oprot->writeStructBegin(\"" << name << "\");" << endl; 
+ 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+      out << endl << indent() << "if "; 
+    } else { 
+      out << " else if "; 
+    } 
+ 
+    out << "(this->__isset." << (*f_iter)->get_name() << ") {" << endl; 
+ 
+    indent_up(); 
+ 
+    // Write field header 
+    out << indent() << "xfer += oprot->writeFieldBegin(" 
+        << "\"" << (*f_iter)->get_name() << "\", " << type_to_enum((*f_iter)->get_type()) << ", " 
+        << (*f_iter)->get_key() << ");" << endl; 
+    // Write field contents 
+    if (pointers) { 
+      generate_serialize_field(out, *f_iter, "(*(this->", "))"); 
+    } else { 
+      generate_serialize_field(out, *f_iter, "this->"); 
+    } 
+    // Write field closer 
+    indent(out) << "xfer += oprot->writeFieldEnd();" << endl; 
+ 
+    indent_down(); 
+    indent(out) << "}"; 
+  } 
+ 
+  // Write the struct map 
+  out << endl << indent() << "xfer += oprot->writeFieldStop();" << endl << indent() 
+      << "xfer += oprot->writeStructEnd();" << endl << indent() << "return xfer;" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates the swap function. 
+ * 
+ * @param out Stream to write to 
+ * @param tstruct The struct 
+ */ 
+void t_cpp_generator::generate_struct_swap(ostream& out, t_struct* tstruct) { 
+  out << indent() << "void swap(" << tstruct->get_name() << " &a, " << tstruct->get_name() 
+      << " &b) {" << endl; 
+  indent_up(); 
+ 
+  // Let argument-dependent name lookup find the correct swap() function to 
+  // use based on the argument types.  If none is found in the arguments' 
+  // namespaces, fall back to ::std::swap(). 
+  out << indent() << "using ::std::swap;" << endl; 
+ 
+  bool has_nonrequired_fields = false; 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  for (vector<t_field*>::const_iterator f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_field* tfield = *f_iter; 
+ 
+    if (tfield->get_req() != t_field::T_REQUIRED) { 
+      has_nonrequired_fields = true; 
+    } 
+ 
+    out << indent() << "swap(a." << tfield->get_name() << ", b." << tfield->get_name() << ");" 
+        << endl; 
+  } 
+ 
+  if (has_nonrequired_fields) { 
+    out << indent() << "swap(a.__isset, b.__isset);" << endl; 
+  } 
+ 
+  // handle empty structs 
+  if (fields.size() == 0) { 
+    out << indent() << "(void) a;" << endl; 
+    out << indent() << "(void) b;" << endl; 
+  } 
+ 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+void t_cpp_generator::generate_struct_ostream_operator_decl(std::ostream& out, t_struct* tstruct) { 
+  out << "std::ostream& operator<<(std::ostream& out, const " 
+      << tstruct->get_name() 
+      << "& obj);" << endl; 
+  out << endl; 
+} 
+ 
+void t_cpp_generator::generate_struct_ostream_operator(std::ostream& out, t_struct* tstruct) { 
+  if (!has_custom_ostream(tstruct)) { 
+    // thrift defines this behavior 
+    out << "std::ostream& operator<<(std::ostream& out, const " 
+        << tstruct->get_name() 
+        << "& obj)" << endl; 
+    scope_up(out); 
+    out << indent() << "obj.printTo(out);" << endl 
+        << indent() << "return out;" << endl; 
+    scope_down(out); 
+    out << endl; 
+  } 
+} 
+ 
+void t_cpp_generator::generate_struct_print_method_decl(std::ostream& out, t_struct* tstruct) { 
+  out << "void "; 
+  if (tstruct) { 
+    out << tstruct->get_name() << "::"; 
+  } 
+  out << "printTo(std::ostream& out) const"; 
+} 
+ 
+void t_cpp_generator::generate_exception_what_method_decl(std::ostream& out, 
+                                                          t_struct* tstruct, 
+                                                          bool external) { 
+  out << "const char* "; 
+  if (external) { 
+    out << tstruct->get_name() << "::"; 
+  } 
+  out << "what() const throw()"; 
+} 
+ 
+namespace struct_ostream_operator_generator { 
+void generate_required_field_value(std::ostream& out, const t_field* field) { 
+  out << " << to_string(" << field->get_name() << ")"; 
+} 
+ 
+void generate_optional_field_value(std::ostream& out, const t_field* field) { 
+  out << "; (__isset." << field->get_name() << " ? (out"; 
+  generate_required_field_value(out, field); 
+  out << ") : (out << \"<null>\"))"; 
+} 
+ 
+void generate_field_value(std::ostream& out, const t_field* field) { 
+  if (field->get_req() == t_field::T_OPTIONAL) 
+    generate_optional_field_value(out, field); 
+  else 
+    generate_required_field_value(out, field); 
+} 
+ 
+void generate_field_name(std::ostream& out, const t_field* field) { 
+  out << "\"" << field->get_name() << "=\""; 
+} 
+ 
+void generate_field(std::ostream& out, const t_field* field) { 
+  generate_field_name(out, field); 
+  generate_field_value(out, field); 
+} 
+ 
+void generate_fields(std::ostream& out, 
+                     const vector<t_field*>& fields, 
+                     const std::string& indent) { 
+  const vector<t_field*>::const_iterator beg = fields.begin(); 
+  const vector<t_field*>::const_iterator end = fields.end(); 
+ 
+  for (vector<t_field*>::const_iterator it = beg; it != end; ++it) { 
+    out << indent << "out << "; 
+ 
+    if (it != beg) { 
+      out << "\", \" << "; 
+    } 
+ 
+    generate_field(out, *it); 
+    out << ";" << endl; 
+  } 
+} 
+} 
+ 
+/** 
+ * Generates operator<< 
+ */ 
+void t_cpp_generator::generate_struct_print_method(std::ostream& out, t_struct* tstruct) { 
+  out << indent(); 
+  generate_struct_print_method_decl(out, tstruct); 
+  out << " {" << endl; 
+ 
+  indent_up(); 
+ 
+  out << indent() << "using ::apache::thrift::to_string;" << endl; 
+  out << indent() << "out << \"" << tstruct->get_name() << "(\";" << endl; 
+  struct_ostream_operator_generator::generate_fields(out, tstruct->get_members(), indent()); 
+  out << indent() << "out << \")\";" << endl; 
+ 
+  indent_down(); 
+  out << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates what() method for exceptions 
+ */ 
+void t_cpp_generator::generate_exception_what_method(std::ostream& out, t_struct* tstruct) { 
+  out << indent(); 
+  generate_exception_what_method_decl(out, tstruct, true); 
+  out << " {" << endl; 
+ 
+  indent_up(); 
+  out << indent() << "try {" << endl; 
+ 
+  indent_up(); 
+  out << indent() << "std::stringstream ss;" << endl; 
+  out << indent() << "ss << \"TException - service has thrown: \" << *this;" << endl; 
+  out << indent() << "this->thriftTExceptionMessageHolder_ = ss.str();" << endl; 
+  out << indent() << "return this->thriftTExceptionMessageHolder_.c_str();" << endl; 
+  indent_down(); 
+ 
+  out << indent() << "} catch (const std::exception&) {" << endl; 
+ 
+  indent_up(); 
+  out << indent() << "return \"TException - service has thrown: " << tstruct->get_name() << "\";" 
+      << endl; 
+  indent_down(); 
+ 
+  out << indent() << "}" << endl; 
+ 
+  indent_down(); 
+  out << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a thrift service. In C++, this comprises an entirely separate 
+ * header and source file. The header file defines the methods and includes 
+ * the data types defined in the main header file, and the implementation 
+ * file contains implementations of the basic printer and default interfaces. 
+ * 
+ * @param tservice The service definition 
+ */ 
+void t_cpp_generator::generate_service(t_service* tservice) { 
+  string svcname = tservice->get_name(); 
+ 
+  // Make output files 
+  string f_header_name = get_out_dir() + svcname + ".h"; 
+  f_header_.open(f_header_name.c_str()); 
+ 
+  // Print header file includes 
+  f_header_ << autogen_comment(); 
+  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 
+              << "namespace apache { namespace thrift { namespace async {" << endl 
+              << "class TAsyncChannel;" << endl << "}}}" << endl; 
+  } 
+  f_header_ << "#include <thrift/TDispatchProcessor.h>" << endl; 
+  if (gen_cob_style_) { 
+    f_header_ << "#include <thrift/async/TAsyncDispatchProcessor.h>" << endl; 
+  } 
+  f_header_ << "#include <thrift/async/TConcurrentClientSyncInfo.h>" << endl; 
+  f_header_ << "#include \"" << get_include_prefix(*get_program()) << program_name_ << "_types.h\"" 
+            << endl; 
+ 
+  t_service* extends_service = tservice->get_extends(); 
+  if (extends_service != NULL) { 
+    f_header_ << "#include \"" << get_include_prefix(*(extends_service->get_program())) 
+              << extends_service->get_name() << ".h\"" << endl; 
+  } 
+ 
+  f_header_ << endl << ns_open_ << endl << endl; 
+ 
+  f_header_ << "#ifdef _MSC_VER\n" 
+               "  #pragma warning( push )\n" 
+               "  #pragma warning (disable : 4250 ) //inheriting methods via dominance \n" 
+               "#endif\n\n"; 
+ 
+  // Service implementation file includes 
+  string f_service_name = get_out_dir() + svcname + ".cpp"; 
+  f_service_.open(f_service_name.c_str()); 
+  f_service_ << autogen_comment(); 
+  f_service_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\"" << endl; 
+  if (gen_cob_style_) { 
+    f_service_ << "#include \"thrift/async/TAsyncChannel.h\"" << endl; 
+  } 
+  if (gen_templates_) { 
+    f_service_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".tcc\"" 
+               << endl; 
+ 
+    string f_service_tcc_name = get_out_dir() + svcname + ".tcc"; 
+    f_service_tcc_.open(f_service_tcc_name.c_str()); 
+    f_service_tcc_ << autogen_comment(); 
+    f_service_tcc_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\"" 
+                   << endl; 
+ 
+    f_service_tcc_ << "#ifndef " << svcname << "_TCC" << endl << "#define " << svcname << "_TCC" 
+                   << endl << endl; 
+ 
+    if (gen_cob_style_) { 
+      f_service_tcc_ << "#include \"thrift/async/TAsyncChannel.h\"" << endl; 
+    } 
+  } 
+ 
+  f_service_ << endl << ns_open_ << endl << endl; 
+  f_service_tcc_ << endl << ns_open_ << endl << endl; 
+ 
+  // Generate all the components 
+  generate_service_interface(tservice, ""); 
+  generate_service_interface_factory(tservice, ""); 
+  generate_service_null(tservice, ""); 
+  generate_service_helpers(tservice); 
+  generate_service_client(tservice, ""); 
+  generate_service_processor(tservice, ""); 
+  generate_service_multiface(tservice); 
+  generate_service_client(tservice, "Concurrent"); 
+ 
+  // Generate skeleton 
+  if (!gen_no_skeleton_) { 
+      generate_service_skeleton(tservice); 
+  } 
+ 
+  // Generate all the cob components 
+  if (gen_cob_style_) { 
+    generate_service_interface(tservice, "CobCl"); 
+    generate_service_interface(tservice, "CobSv"); 
+    generate_service_interface_factory(tservice, "CobSv"); 
+    generate_service_null(tservice, "CobSv"); 
+    generate_service_client(tservice, "Cob"); 
+    generate_service_processor(tservice, "Cob"); 
+ 
+    if (!gen_no_skeleton_) { 
+      generate_service_async_skeleton(tservice); 
+    } 
+ 
+  } 
+ 
+  f_header_ << "#ifdef _MSC_VER\n" 
+               "  #pragma warning( pop )\n" 
+               "#endif\n\n"; 
+ 
+  // Close the namespace 
+  f_service_ << ns_close_ << endl << endl; 
+  f_service_tcc_ << ns_close_ << endl << endl; 
+  f_header_ << ns_close_ << endl << endl; 
+ 
+  // TODO(simpkins): Make this a separate option 
+  if (gen_templates_) { 
+    f_header_ << "#include \"" << get_include_prefix(*get_program()) << svcname << ".tcc\"" << endl 
+              << "#include \"" << get_include_prefix(*get_program()) << program_name_ 
+              << "_types.tcc\"" << endl << endl; 
+  } 
+ 
+  f_header_ << "#endif" << endl; 
+  f_service_tcc_ << "#endif" << endl; 
+ 
+  // Close the files 
+  f_service_tcc_.close(); 
+  f_service_.close(); 
+  f_header_.close(); 
+} 
+ 
+/** 
+ * Generates helper functions for a service. Basically, this generates types 
+ * for all the arguments and results to functions. 
+ * 
+ * @param tservice The service to generate a header definition for 
+ */ 
+void t_cpp_generator::generate_service_helpers(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_); 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    t_struct* ts = (*f_iter)->get_arglist(); 
+    string name_orig = ts->get_name(); 
+ 
+    // TODO(dreiss): Why is this stuff not in generate_function_helpers? 
+    ts->set_name(tservice->get_name() + "_" + (*f_iter)->get_name() + "_args"); 
+    generate_struct_declaration(f_header_, ts, false); 
+    generate_struct_definition(out, f_service_, ts, false); 
+    generate_struct_reader(out, ts); 
+    generate_struct_writer(out, ts); 
+    ts->set_name(tservice->get_name() + "_" + (*f_iter)->get_name() + "_pargs"); 
+    generate_struct_declaration(f_header_, ts, false, true, false, true); 
+    generate_struct_definition(out, f_service_, ts, false); 
+    generate_struct_writer(out, ts, true); 
+    ts->set_name(name_orig); 
+ 
+    generate_function_helpers(tservice, *f_iter); 
+  } 
+} 
+ 
+/** 
+ * Generates a service interface definition. 
+ * 
+ * @param tservice The service to generate a header definition for 
+ */ 
+void t_cpp_generator::generate_service_interface(t_service* tservice, string style) { 
+ 
+  string service_if_name = service_name_ + style + "If"; 
+  if (style == "CobCl") { 
+    // Forward declare the client. 
+    string client_name = service_name_ + "CobClient"; 
+    if (gen_templates_) { 
+      client_name += "T"; 
+      service_if_name += "T"; 
+      indent(f_header_) << "template <class Protocol_>" << endl; 
+    } 
+    indent(f_header_) << "class " << client_name << ";" << endl << endl; 
+  } 
+ 
+  string extends = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = " : virtual public " + type_name(tservice->get_extends()) + style + "If"; 
+    if (style == "CobCl" && gen_templates_) { 
+      // TODO(simpkins): If gen_templates_ is enabled, we currently assume all 
+      // parent services were also generated with templates enabled. 
+      extends += "T<Protocol_>"; 
+    } 
+  } 
+ 
+  if (style == "CobCl" && gen_templates_) { 
+    f_header_ << "template <class Protocol_>" << endl; 
+  } 
+  f_header_ << "class " << service_if_name << extends << " {" << endl << " public:" << endl; 
+  indent_up(); 
+  f_header_ << indent() << "virtual ~" << service_if_name << "() {}" << endl; 
+ 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    if ((*f_iter)->has_doc()) 
+      f_header_ << endl; 
+    generate_java_doc(f_header_, *f_iter); 
+    f_header_ << indent() << "virtual " << function_signature(*f_iter, style) << " = 0;" << endl; 
+  } 
+  indent_down(); 
+  f_header_ << "};" << endl << endl; 
+ 
+  if (style == "CobCl" && gen_templates_) { 
+    // generate a backwards-compatible typedef for clients that do not 
+    // know about the new template-style code 
+    f_header_ << "typedef " << service_if_name << "< ::apache::thrift::protocol::TProtocol> " 
+              << service_name_ << style << "If;" << endl << endl; 
+  } 
+} 
+ 
+/** 
+ * Generates a service interface factory. 
+ * 
+ * @param tservice The service to generate an interface factory for. 
+ */ 
+void t_cpp_generator::generate_service_interface_factory(t_service* tservice, string style) { 
+  string service_if_name = service_name_ + style + "If"; 
+ 
+  // Figure out the name of the upper-most parent class. 
+  // Getting everything to work out properly with inheritance is annoying. 
+  // Here's what we're doing for now: 
+  // 
+  // - All handlers implement getHandler(), but subclasses use covariant return 
+  //   types to return their specific service interface class type.  We have to 
+  //   use raw pointers because of this; shared_ptr<> can't be used for 
+  //   covariant return types. 
+  // 
+  // - Since we're not using shared_ptr<>, we also provide a releaseHandler() 
+  //   function that must be called to release a pointer to a handler obtained 
+  //   via getHandler(). 
+  // 
+  //   releaseHandler() always accepts a pointer to the upper-most parent class 
+  //   type.  This is necessary since the parent versions of releaseHandler() 
+  //   may accept any of the parent types, not just the most specific subclass 
+  //   type.  Implementations can use dynamic_cast to cast the pointer to the 
+  //   subclass type if desired. 
+  t_service* base_service = tservice; 
+  while (base_service->get_extends() != NULL) { 
+    base_service = base_service->get_extends(); 
+  } 
+  string base_if_name = type_name(base_service) + style + "If"; 
+ 
+  // Generate the abstract factory class 
+  string factory_name = service_if_name + "Factory"; 
+  string extends; 
+  if (tservice->get_extends() != NULL) { 
+    extends = " : virtual public " + type_name(tservice->get_extends()) + style + "IfFactory"; 
+  } 
+ 
+  f_header_ << "class " << factory_name << extends << " {" << endl << " public:" << endl; 
+  indent_up(); 
+  f_header_ << indent() << "typedef " << service_if_name << " Handler;" << endl << endl << indent() 
+            << "virtual ~" << factory_name << "() {}" << endl << endl << indent() << "virtual " 
+            << service_if_name << "* getHandler(" 
+            << "const ::apache::thrift::TConnectionInfo& connInfo) = 0;" << endl << indent() 
+            << "virtual void releaseHandler(" << base_if_name << "* /* handler */) = 0;" << endl; 
+ 
+  indent_down(); 
+  f_header_ << "};" << endl << endl; 
+ 
+  // Generate the singleton factory class 
+  string singleton_factory_name = service_if_name + "SingletonFactory"; 
+  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 
+            << ">& iface) : iface_(iface) {}" << endl << indent() << "virtual ~" 
+            << singleton_factory_name << "() {}" << endl << endl << indent() << "virtual " 
+            << service_if_name << "* getHandler(" 
+            << "const ::apache::thrift::TConnectionInfo&) {" << endl << indent() 
+            << "  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 
+            << "> iface_;" << endl; 
+ 
+  indent_down(); 
+  f_header_ << "};" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a null implementation of the service. 
+ * 
+ * @param tservice The service to generate a header definition for 
+ */ 
+void t_cpp_generator::generate_service_null(t_service* tservice, string style) { 
+  string extends = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = " , virtual public " + type_name(tservice->get_extends()) + style + "Null"; 
+  } 
+  f_header_ << "class " << service_name_ << style << "Null : virtual public " << service_name_ 
+            << style << "If" << extends << " {" << endl << " public:" << endl; 
+  indent_up(); 
+  f_header_ << indent() << "virtual ~" << service_name_ << style << "Null() {}" << endl; 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    f_header_ << indent() << function_signature(*f_iter, style, "", false) << " {" << endl; 
+    indent_up(); 
+ 
+    t_type* returntype = (*f_iter)->get_returntype(); 
+    t_field returnfield(returntype, "_return"); 
+ 
+    if (style == "") { 
+      if (returntype->is_void() || is_complex_type(returntype)) { 
+        f_header_ << indent() << "return;" << endl; 
+      } else { 
+        f_header_ << indent() << declare_field(&returnfield, true) << endl << indent() 
+                  << "return _return;" << endl; 
+      } 
+    } else if (style == "CobSv") { 
+      if (returntype->is_void()) { 
+        f_header_ << indent() << "return cob();" << endl; 
+      } else { 
+        t_field returnfield(returntype, "_return"); 
+        f_header_ << indent() << declare_field(&returnfield, true) << endl << indent() 
+                  << "return cob(_return);" << endl; 
+      } 
+ 
+    } else { 
+      throw "UNKNOWN STYLE"; 
+    } 
+ 
+    indent_down(); 
+    f_header_ << indent() << "}" << endl; 
+  } 
+  indent_down(); 
+  f_header_ << "};" << endl << endl; 
+} 
+ 
+void t_cpp_generator::generate_function_call(ostream& out, 
+                                             t_function* tfunction, 
+                                             string target, 
+                                             string iface, 
+                                             string arg_prefix) { 
+  bool first = true; 
+  t_type* ret_type = get_true_type(tfunction->get_returntype()); 
+  out << indent(); 
+  if (!tfunction->is_oneway() && !ret_type->is_void()) { 
+    if (is_complex_type(ret_type)) { 
+      first = false; 
+      out << iface << "->" << tfunction->get_name() << "(" << target; 
+    } else { 
+      out << target << " = " << iface << "->" << tfunction->get_name() << "("; 
+    } 
+  } else { 
+    out << iface << "->" << tfunction->get_name() << "("; 
+  } 
+  const std::vector<t_field*>& fields = tfunction->get_arglist()->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      out << ", "; 
+    } 
+    out << arg_prefix << (*f_iter)->get_name(); 
+  } 
+  out << ");" << endl; 
+} 
+ 
+void t_cpp_generator::generate_service_async_skeleton(t_service* tservice) { 
+  string svcname = tservice->get_name(); 
+ 
+  // Service implementation file includes 
+  string f_skeleton_name = get_out_dir() + svcname + "_async_server.skeleton.cpp"; 
+ 
+  string ns = namespace_prefix(tservice->get_program()->get_namespace("cpp")); 
+ 
+  ofstream_with_content_based_conditional_update f_skeleton; 
+  f_skeleton.open(f_skeleton_name.c_str()); 
+  f_skeleton << "// This autogenerated skeleton file illustrates one way to adapt a synchronous" 
+             << endl << "// interface into an asynchronous interface. You should copy it to another" 
+             << endl 
+             << "// filename to avoid overwriting it and rewrite as asynchronous any functions" 
+             << endl << "// that would otherwise introduce unwanted latency." << endl << endl 
+             << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\"" << endl 
+             << "#include <thrift/protocol/TBinaryProtocol.h>" << endl << endl 
+             << "using namespace ::apache::thrift;" << endl 
+             << "using namespace ::apache::thrift::protocol;" << endl 
+             << "using namespace ::apache::thrift::transport;" << endl 
+             << "using namespace ::apache::thrift::async;" << endl << endl; 
+ 
+  // the following code would not compile: 
+  // using namespace ; 
+  // using namespace ::; 
+  if ((!ns.empty()) && (ns.compare(" ::") != 0)) { 
+    f_skeleton << "using namespace " << string(ns, 0, ns.size() - 2) << ";" << endl << endl; 
+  } 
+ 
+  f_skeleton << "class " << svcname << "AsyncHandler : " 
+             << "public " << svcname << "CobSvIf {" << endl << " public:" << endl; 
+  indent_up(); 
+  f_skeleton << indent() << svcname << "AsyncHandler() {" << endl << indent() 
+             << "  syncHandler_ = std::auto_ptr<" << svcname << "Handler>(new " << svcname 
+             << "Handler);" << endl << indent() << "  // Your initialization goes here" << endl 
+             << indent() << "}" << endl; 
+  f_skeleton << indent() << "virtual ~" << service_name_ << "AsyncHandler();" << endl; 
+ 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    f_skeleton << endl << indent() << function_signature(*f_iter, "CobSv", "", true) << " {" 
+               << endl; 
+    indent_up(); 
+ 
+    t_type* returntype = (*f_iter)->get_returntype(); 
+    t_field returnfield(returntype, "_return"); 
+ 
+    string target = returntype->is_void() ? "" : "_return"; 
+    if (!returntype->is_void()) { 
+      f_skeleton << indent() << declare_field(&returnfield, true) << endl; 
+    } 
+    generate_function_call(f_skeleton, *f_iter, target, "syncHandler_", ""); 
+    f_skeleton << indent() << "return cob(" << target << ");" << endl; 
+ 
+    scope_down(f_skeleton); 
+  } 
+  f_skeleton << endl << " protected:" << endl << indent() << "std::auto_ptr<" << svcname 
+             << "Handler> syncHandler_;" << endl; 
+  indent_down(); 
+  f_skeleton << "};" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a multiface, which is a single server that just takes a set 
+ * of objects implementing the interface and calls them all, returning the 
+ * value of the last one to be called. 
+ * 
+ * @param tservice The service to generate a multiserver for. 
+ */ 
+void t_cpp_generator::generate_service_multiface(t_service* tservice) { 
+  // Generate the dispatch methods 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+ 
+  string extends = ""; 
+  string extends_multiface = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = type_name(tservice->get_extends()); 
+    extends_multiface = ", public " + extends + "Multiface"; 
+  } 
+ 
+  string list_type = string("std::vector<apache::thrift::stdcxx::shared_ptr<") + service_name_ + "If> >"; 
+ 
+  // Generate the header portion 
+  f_header_ << "class " << service_name_ << "Multiface : " 
+            << "virtual public " << service_name_ << "If" << extends_multiface << " {" << endl 
+            << " public:" << endl; 
+  indent_up(); 
+  f_header_ << indent() << service_name_ << "Multiface(" << list_type 
+            << "& ifaces) : ifaces_(ifaces) {" << endl; 
+  if (!extends.empty()) { 
+    f_header_ << indent() 
+              << "  std::vector<apache::thrift::stdcxx::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; 
+  } 
+  f_header_ << indent() << "}" << endl << indent() << "virtual ~" << service_name_ 
+            << "Multiface() {}" << endl; 
+  indent_down(); 
+ 
+  // Protected data members 
+  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<" 
+            << service_name_ << "If> iface) {" << endl; 
+  if (!extends.empty()) { 
+    f_header_ << indent() << "  " << extends << "Multiface::add(iface);" << endl; 
+  } 
+  f_header_ << indent() << "  ifaces_.push_back(iface);" << endl << indent() << "}" << endl; 
+  indent_down(); 
+ 
+  f_header_ << indent() << " public:" << endl; 
+  indent_up(); 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    t_struct* arglist = (*f_iter)->get_arglist(); 
+    const vector<t_field*>& args = arglist->get_members(); 
+    vector<t_field*>::const_iterator a_iter; 
+ 
+    string call = string("ifaces_[i]->") + (*f_iter)->get_name() + "("; 
+    bool first = true; 
+    if (is_complex_type((*f_iter)->get_returntype())) { 
+      call += "_return"; 
+      first = false; 
+    } 
+    for (a_iter = args.begin(); a_iter != args.end(); ++a_iter) { 
+      if (first) { 
+        first = false; 
+      } else { 
+        call += ", "; 
+      } 
+      call += (*a_iter)->get_name(); 
+    } 
+    call += ")"; 
+ 
+    f_header_ << indent() << function_signature(*f_iter, "") << " {" << endl; 
+    indent_up(); 
+    f_header_ << indent() << "size_t sz = ifaces_.size();" << endl << indent() << "size_t i = 0;" 
+              << endl << indent() << "for (; i < (sz - 1); ++i) {" << endl; 
+    indent_up(); 
+    f_header_ << indent() << call << ";" << endl; 
+    indent_down(); 
+    f_header_ << indent() << "}" << endl; 
+ 
+    if (!(*f_iter)->get_returntype()->is_void()) { 
+      if (is_complex_type((*f_iter)->get_returntype())) { 
+        f_header_ << indent() << call << ";" << endl << indent() << "return;" << endl; 
+      } else { 
+        f_header_ << indent() << "return " << call << ";" << endl; 
+      } 
+    } else { 
+      f_header_ << indent() << call << ";" << endl; 
+    } 
+ 
+    indent_down(); 
+    f_header_ << indent() << "}" << endl << endl; 
+  } 
+ 
+  indent_down(); 
+  f_header_ << indent() << "};" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a service client definition. 
+ * 
+ * @param tservice The service to generate a server for. 
+ */ 
+void t_cpp_generator::generate_service_client(t_service* tservice, string style) { 
+  string ifstyle; 
+  if (style == "Cob") { 
+    ifstyle = "CobCl"; 
+  } 
+ 
+  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_); 
+  string template_header, template_suffix, short_suffix, protocol_type, _this; 
+  string const prot_factory_type = "::apache::thrift::protocol::TProtocolFactory"; 
+  if (gen_templates_) { 
+    template_header = "template <class Protocol_>\n"; 
+    short_suffix = "T"; 
+    template_suffix = "T<Protocol_>"; 
+    protocol_type = "Protocol_"; 
+    _this = "this->"; 
+  } else { 
+    protocol_type = "::apache::thrift::protocol::TProtocol"; 
+  } 
+  string prot_ptr = "apache::thrift::stdcxx::shared_ptr< " + protocol_type + ">"; 
+  string client_suffix = "Client" + template_suffix; 
+  string if_suffix = "If"; 
+  if (style == "Cob") { 
+    if_suffix += template_suffix; 
+  } 
+ 
+  string extends = ""; 
+  string extends_client = ""; 
+  if (tservice->get_extends() != NULL) { 
+    // TODO(simpkins): If gen_templates_ is enabled, we currently assume all 
+    // parent services were also generated with templates enabled. 
+    extends = type_name(tservice->get_extends()); 
+    extends_client = ", public " + extends + style + client_suffix; 
+  } 
+ 
+  // Generate the header portion 
+  if (style == "Concurrent") { 
+    f_header_ << "// The \'concurrent\' client is a thread safe client that correctly handles\n" 
+                 "// out of order responses.  It is slower than the regular client, so should\n" 
+                 "// only be used when you need to share a connection among multiple threads\n"; 
+  } 
+  f_header_ << template_header << "class " << service_name_ << style << "Client" << short_suffix 
+            << " : " 
+            << "virtual public " << service_name_ << ifstyle << if_suffix << extends_client << " {" 
+            << endl << " public:" << endl; 
+ 
+  indent_up(); 
+  if (style != "Cob") { 
+    f_header_ << indent() << service_name_ << style << "Client" << short_suffix << "(" << prot_ptr 
+              << " prot) "; 
+ 
+    if (extends.empty()) { 
+      f_header_ << "{" << endl; 
+      f_header_ << indent() << "  setProtocol" << short_suffix << "(prot);" << endl << indent() 
+                << "}" << endl; 
+    } else { 
+      f_header_ << ":" << endl; 
+      f_header_ << indent() << "  " << extends << style << client_suffix << "(prot, prot) {}" 
+                << endl; 
+    } 
+ 
+    f_header_ << indent() << service_name_ << style << "Client" << short_suffix << "(" << prot_ptr 
+              << " iprot, " << prot_ptr << " oprot) "; 
+    if (extends.empty()) { 
+      f_header_ << "{" << endl; 
+      f_header_ << indent() << "  setProtocol" << short_suffix << "(iprot,oprot);" << endl 
+                << indent() << "}" << endl; 
+    } else { 
+      f_header_ << ":" << indent() << "  " << extends << style << client_suffix 
+                << "(iprot, oprot) {}" << endl; 
+    } 
+ 
+    // create the setProtocol methods 
+    if (extends.empty()) { 
+      f_header_ << " private:" << endl; 
+      // 1: one parameter 
+      f_header_ << indent() << "void setProtocol" << short_suffix << "(" << prot_ptr << " prot) {" 
+                << endl; 
+      f_header_ << indent() << "setProtocol" << short_suffix << "(prot,prot);" << endl; 
+      f_header_ << indent() << "}" << endl; 
+      // 2: two parameter 
+      f_header_ << indent() << "void setProtocol" << short_suffix << "(" << prot_ptr << " iprot, " 
+                << prot_ptr << " oprot) {" << endl; 
+ 
+      f_header_ << indent() << "  piprot_=iprot;" << endl << indent() << "  poprot_=oprot;" << endl 
+                << indent() << "  iprot_ = iprot.get();" << endl << indent() 
+                << "  oprot_ = oprot.get();" << endl; 
+ 
+      f_header_ << indent() << "}" << endl; 
+      f_header_ << " public:" << endl; 
+    } 
+ 
+    // Generate getters for the protocols. 
+    // 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() {" 
+              << endl << indent() << "  return " << _this << "piprot_;" << endl << indent() << "}" 
+              << endl; 
+ 
+    f_header_ << indent() 
+              << "apache::thrift::stdcxx::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, " 
+              << "::apache::thrift::protocol::TProtocolFactory* protocolFactory) :" << endl; 
+    if (extends.empty()) { 
+      f_header_ << indent() << "  channel_(channel)," << endl << indent() 
+                << "  itrans_(new ::apache::thrift::transport::TMemoryBuffer())," << endl 
+                << indent() << "  otrans_(new ::apache::thrift::transport::TMemoryBuffer())," 
+                << endl; 
+      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_>(" 
+                  << "protocolFactory->getProtocol(itrans_)))," << endl << indent() 
+                  << "  poprot_(::apache::thrift::stdcxx::dynamic_pointer_cast<Protocol_>(" 
+                  << "protocolFactory->getProtocol(otrans_))) {" << endl; 
+        // Throw a TException if either dynamic cast failed. 
+        f_header_ << indent() << "  if (!piprot_ || !poprot_) {" << endl << indent() 
+                  << "    throw ::apache::thrift::TException(\"" 
+                  << "TProtocolFactory returned unexpected protocol type in " << service_name_ 
+                  << style << "Client" << short_suffix << " constructor\");" << endl << indent() 
+                  << "  }" << endl; 
+      } else { 
+        f_header_ << indent() << "  piprot_(protocolFactory->getProtocol(itrans_))," << endl 
+                  << indent() << "  poprot_(protocolFactory->getProtocol(otrans_)) {" << endl; 
+      } 
+      f_header_ << indent() << "  iprot_ = piprot_.get();" << endl << indent() 
+                << "  oprot_ = poprot_.get();" << endl << indent() << "}" << endl; 
+    } else { 
+      f_header_ << indent() << "  " << extends << style << client_suffix 
+                << "(channel, protocolFactory) {}" << endl; 
+    } 
+  } 
+ 
+  if (style == "Cob") { 
+    f_header_ << indent() 
+              << "::apache::thrift::stdcxx::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; 
+    } 
+  } 
+ 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    indent(f_header_) << function_signature(*f_iter, ifstyle) << ";" << endl; 
+    // TODO(dreiss): Use private inheritance to avoid generating thise in cob-style. 
+    if (style == "Concurrent" && !(*f_iter)->is_oneway()) { 
+      // concurrent clients need to move the seqid from the send function to the 
+      // recv function.  Oneway methods don't have a recv function, so we don't need to 
+      // move the seqid for them.  Attempting to do so would result in a seqid leak. 
+      t_function send_function(g_type_i32, /*returning seqid*/ 
+                               string("send_") + (*f_iter)->get_name(), 
+                               (*f_iter)->get_arglist()); 
+      indent(f_header_) << function_signature(&send_function, "") << ";" << endl; 
+    } else { 
+      t_function send_function(g_type_void, 
+                               string("send_") + (*f_iter)->get_name(), 
+                               (*f_iter)->get_arglist()); 
+      indent(f_header_) << function_signature(&send_function, "") << ";" << endl; 
+    } 
+    if (!(*f_iter)->is_oneway()) { 
+      if (style == "Concurrent") { 
+        t_field seqIdArg(g_type_i32, "seqid"); 
+        t_struct seqIdArgStruct(program_); 
+        seqIdArgStruct.append(&seqIdArg); 
+        t_function recv_function((*f_iter)->get_returntype(), 
+                                 string("recv_") + (*f_iter)->get_name(), 
+                                 &seqIdArgStruct); 
+        indent(f_header_) << function_signature(&recv_function, "") << ";" << endl; 
+      } else { 
+        t_struct noargs(program_); 
+        t_function recv_function((*f_iter)->get_returntype(), 
+                                 string("recv_") + (*f_iter)->get_name(), 
+                                 &noargs); 
+        indent(f_header_) << function_signature(&recv_function, "") << ";" << endl; 
+      } 
+    } 
+  } 
+  indent_down(); 
+ 
+  if (extends.empty()) { 
+    f_header_ << " protected:" << endl; 
+    indent_up(); 
+ 
+    if (style == "Cob") { 
+      f_header_ << indent() 
+                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::async::TAsyncChannel> channel_;" << endl 
+                << indent() 
+                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> itrans_;" << endl 
+                << indent() 
+                << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::transport::TMemoryBuffer> otrans_;" 
+                << endl; 
+    } 
+    f_header_ << 
+      indent() << prot_ptr << " piprot_;" << endl << 
+      indent() << prot_ptr << " poprot_;" << endl << 
+      indent() << protocol_type << "* iprot_;" << endl << 
+      indent() << protocol_type << "* oprot_;" << endl; 
+ 
+    if (style == "Concurrent") { 
+      f_header_ << 
+        indent() << "::apache::thrift::async::TConcurrentClientSyncInfo sync_;"<<endl; 
+    } 
+    indent_down(); 
+  } 
+ 
+  f_header_ << "};" << endl << endl; 
+ 
+  if (gen_templates_) { 
+    // Output a backwards compatibility typedef using 
+    // TProtocol as the template parameter. 
+    f_header_ << "typedef " << service_name_ << style 
+              << "ClientT< ::apache::thrift::protocol::TProtocol> " << service_name_ << style 
+              << "Client;" << endl << endl; 
+  } 
+ 
+  string scope = service_name_ + style + client_suffix + "::"; 
+ 
+  // Generate client method implementations 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    string seqIdCapture; 
+    string seqIdUse; 
+    string seqIdCommaUse; 
+    if (style == "Concurrent" && !(*f_iter)->is_oneway()) { 
+      seqIdCapture = "int32_t seqid = "; 
+      seqIdUse = "seqid"; 
+      seqIdCommaUse = ", seqid"; 
+    } 
+ 
+    string funname = (*f_iter)->get_name(); 
+ 
+    // Open function 
+    if (gen_templates_) { 
+      indent(out) << template_header; 
+    } 
+    indent(out) << function_signature(*f_iter, ifstyle, scope) << endl; 
+    scope_up(out); 
+    indent(out) << seqIdCapture << "send_" << funname << "("; 
+ 
+    // Get the struct of function call params 
+    t_struct* arg_struct = (*f_iter)->get_arglist(); 
+ 
+    // Declare the function arguments 
+    const vector<t_field*>& fields = arg_struct->get_members(); 
+    vector<t_field*>::const_iterator fld_iter; 
+    bool first = true; 
+    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+      if (first) { 
+        first = false; 
+      } else { 
+        out << ", "; 
+      } 
+      out << (*fld_iter)->get_name(); 
+    } 
+    out << ");" << endl; 
+ 
+    if (style != "Cob") { 
+      if (!(*f_iter)->is_oneway()) { 
+        out << indent(); 
+        if (!(*f_iter)->get_returntype()->is_void()) { 
+          if (is_complex_type((*f_iter)->get_returntype())) { 
+            out << "recv_" << funname << "(_return" << seqIdCommaUse << ");" << endl; 
+          } else { 
+            out << "return recv_" << funname << "(" << seqIdUse << ");" << endl; 
+          } 
+        } else { 
+          out << "recv_" << funname << "(" << seqIdUse << ");" << endl; 
+        } 
+      } 
+    } else { 
+      if (!(*f_iter)->is_oneway()) { 
+        out << indent() << _this << "channel_->sendAndRecvMessage(" 
+            << "::apache::thrift::stdcxx::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; 
+      } 
+    } 
+    scope_down(out); 
+    out << endl; 
+ 
+    // if (style != "Cob") // TODO(dreiss): Libify the client and don't generate this for cob-style 
+    if (true) { 
+      t_type* send_func_return_type = g_type_void; 
+      if (style == "Concurrent" && !(*f_iter)->is_oneway()) { 
+        send_func_return_type = g_type_i32; 
+      } 
+      // Function for sending 
+      t_function send_function(send_func_return_type, 
+                               string("send_") + (*f_iter)->get_name(), 
+                               (*f_iter)->get_arglist()); 
+ 
+      // Open the send function 
+      if (gen_templates_) { 
+        indent(out) << template_header; 
+      } 
+      indent(out) << function_signature(&send_function, "", scope) << endl; 
+      scope_up(out); 
+ 
+      // Function arguments and results 
+      string argsname = tservice->get_name() + "_" + (*f_iter)->get_name() + "_pargs"; 
+      string resultname = tservice->get_name() + "_" + (*f_iter)->get_name() + "_presult"; 
+ 
+      string cseqidVal = "0"; 
+      if (style == "Concurrent") { 
+        if (!(*f_iter)->is_oneway()) { 
+          cseqidVal = "this->sync_.generateSeqId()"; 
+        } 
+      } 
+      // Serialize the request 
+      out << 
+        indent() << "int32_t cseqid = " << cseqidVal << ";" << endl; 
+      if(style == "Concurrent") { 
+        out << 
+          indent() << "::apache::thrift::async::TConcurrentSendSentry sentry(&this->sync_);" << endl; 
+      } 
+      if (style == "Cob") { 
+        out << 
+          indent() << _this << "otrans_->resetBuffer();" << endl; 
+      } 
+      out << 
+        indent() << _this << "oprot_->writeMessageBegin(\"" << 
+        (*f_iter)->get_name() << 
+        "\", ::apache::thrift::protocol::" << ((*f_iter)->is_oneway() ? "T_ONEWAY" : "T_CALL") << 
+        ", cseqid);" << endl << endl << 
+        indent() << argsname << " args;" << endl; 
+ 
+      for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+        out << indent() << "args." << (*fld_iter)->get_name() << " = &" << (*fld_iter)->get_name() 
+            << ";" << endl; 
+      } 
+ 
+      out << indent() << "args.write(" << _this << "oprot_);" << endl << endl << indent() << _this 
+          << "oprot_->writeMessageEnd();" << endl << indent() << _this 
+          << "oprot_->getTransport()->writeEnd();" << endl << indent() << _this 
+          << "oprot_->getTransport()->flush();" << endl; 
+ 
+      if (style == "Concurrent") { 
+        out << endl << indent() << "sentry.commit();" << endl; 
+ 
+        if (!(*f_iter)->is_oneway()) { 
+          out << indent() << "return cseqid;" << endl; 
+        } 
+      } 
+      scope_down(out); 
+      out << endl; 
+ 
+      // Generate recv function only if not an oneway function 
+      if (!(*f_iter)->is_oneway()) { 
+        t_struct noargs(program_); 
+ 
+        t_field seqIdArg(g_type_i32, "seqid"); 
+        t_struct seqIdArgStruct(program_); 
+        seqIdArgStruct.append(&seqIdArg); 
+ 
+        t_struct* recv_function_args = &noargs; 
+        if (style == "Concurrent") { 
+          recv_function_args = &seqIdArgStruct; 
+        } 
+ 
+        t_function recv_function((*f_iter)->get_returntype(), 
+                                 string("recv_") + (*f_iter)->get_name(), 
+                                 recv_function_args); 
+        // Open the recv function 
+        if (gen_templates_) { 
+          indent(out) << template_header; 
+        } 
+        indent(out) << function_signature(&recv_function, "", scope) << endl; 
+        scope_up(out); 
+ 
+        out << endl << 
+          indent() << "int32_t rseqid = 0;" << endl << 
+          indent() << "std::string fname;" << endl << 
+          indent() << "::apache::thrift::protocol::TMessageType mtype;" << endl; 
+        if(style == "Concurrent") { 
+          out << 
+            endl << 
+            indent() << "// the read mutex gets dropped and reacquired as part of waitForWork()" << endl << 
+            indent() << "// The destructor of this sentry wakes up other clients" << endl << 
+            indent() << "::apache::thrift::async::TConcurrentRecvSentry sentry(&this->sync_, seqid);" << endl; 
+        } 
+        if (style == "Cob" && !gen_no_client_completion_) { 
+          out << indent() << "bool completed = false;" << endl << endl << indent() << "try {"; 
+          indent_up(); 
+        } 
+        out << endl; 
+        if (style == "Concurrent") { 
+          out << 
+            indent() << "while(true) {" << endl << 
+            indent() << "  if(!this->sync_.getPending(fname, mtype, rseqid)) {" << endl; 
+          indent_up(); 
+          indent_up(); 
+        } 
+        out << 
+          indent() << _this << "iprot_->readMessageBegin(fname, mtype, rseqid);" << endl; 
+        if (style == "Concurrent") { 
+          scope_down(out); 
+          out << indent() << "if(seqid == rseqid) {" << endl; 
+          indent_up(); 
+        } 
+        out << 
+          indent() << "if (mtype == ::apache::thrift::protocol::T_EXCEPTION) {" << endl << 
+          indent() << "  ::apache::thrift::TApplicationException x;" << endl << 
+          indent() << "  x.read(" << _this << "iprot_);" << endl << 
+          indent() << "  " << _this << "iprot_->readMessageEnd();" << endl << 
+          indent() << "  " << _this << "iprot_->getTransport()->readEnd();" << endl; 
+        if (style == "Cob" && !gen_no_client_completion_) { 
+          out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);" 
+              << endl; 
+        } 
+        if (style == "Concurrent") { 
+          out << indent() << "  sentry.commit();" << endl; 
+        } 
+        out << 
+          indent() << "  throw x;" << endl << 
+          indent() << "}" << endl << 
+          indent() << "if (mtype != ::apache::thrift::protocol::T_REPLY) {" << endl << 
+          indent() << "  " << _this << "iprot_->skip(" << "::apache::thrift::protocol::T_STRUCT);" << endl << 
+          indent() << "  " << _this << "iprot_->readMessageEnd();" << endl << 
+          indent() << "  " << _this << "iprot_->getTransport()->readEnd();" << endl; 
+        if (style == "Cob" && !gen_no_client_completion_) { 
+          out << indent() << "  completed = true;" << endl << indent() << "  completed__(false);" 
+              << endl; 
+        } 
+        out << 
+          indent() << "}" << endl << 
+          indent() << "if (fname.compare(\"" << (*f_iter)->get_name() << "\") != 0) {" << endl << 
+          indent() << "  " << _this << "iprot_->skip(" << "::apache::thrift::protocol::T_STRUCT);" << endl << 
+          indent() << "  " << _this << "iprot_->readMessageEnd();" << endl << 
+          indent() << "  " << _this << "iprot_->getTransport()->readEnd();" << endl; 
+        if (style == "Cob" && !gen_no_client_completion_) { 
+          out << indent() << "  completed = true;" << endl << indent() << "  completed__(false);" 
+              << endl; 
+        } 
+        if (style == "Concurrent") { 
+          out << endl << 
+            indent() << "  // in a bad state, don't commit" << endl << 
+            indent() << "  using ::apache::thrift::protocol::TProtocolException;" << endl << 
+            indent() << "  throw TProtocolException(TProtocolException::INVALID_DATA);" << endl; 
+        } 
+        out << indent() << "}" << endl; 
+ 
+        if (!(*f_iter)->get_returntype()->is_void() 
+            && !is_complex_type((*f_iter)->get_returntype())) { 
+          t_field returnfield((*f_iter)->get_returntype(), "_return"); 
+          out << indent() << declare_field(&returnfield) << endl; 
+        } 
+ 
+        out << indent() << resultname << " result;" << endl; 
+ 
+        if (!(*f_iter)->get_returntype()->is_void()) { 
+          out << indent() << "result.success = &_return;" << endl; 
+        } 
+ 
+        out << indent() << "result.read(" << _this << "iprot_);" << endl << indent() << _this 
+            << "iprot_->readMessageEnd();" << endl << indent() << _this 
+            << "iprot_->getTransport()->readEnd();" << endl << endl; 
+ 
+        // Careful, only look for _result if not a void function 
+        if (!(*f_iter)->get_returntype()->is_void()) { 
+          if (is_complex_type((*f_iter)->get_returntype())) { 
+            out << 
+              indent() << "if (result.__isset.success) {" << endl; 
+            out << 
+              indent() << "  // _return pointer has now been filled" << endl; 
+            if (style == "Cob" && !gen_no_client_completion_) { 
+              out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);" 
+                  << endl; 
+            } 
+            if (style == "Concurrent") { 
+              out << indent() << "  sentry.commit();" << endl; 
+            } 
+            out << 
+              indent() << "  return;" << endl << 
+              indent() << "}" << endl; 
+          } else { 
+            out << indent() << "if (result.__isset.success) {" << endl; 
+            if (style == "Cob" && !gen_no_client_completion_) { 
+              out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);" 
+                  << endl; 
+            } 
+            if (style == "Concurrent") { 
+              out << indent() << "  sentry.commit();" << endl; 
+            } 
+            out << indent() << "  return _return;" << endl << indent() << "}" << endl; 
+          } 
+        } 
+ 
+        t_struct* xs = (*f_iter)->get_xceptions(); 
+        const std::vector<t_field*>& xceptions = xs->get_members(); 
+        vector<t_field*>::const_iterator x_iter; 
+        for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+          out << indent() << "if (result.__isset." << (*x_iter)->get_name() << ") {" << endl; 
+          if (style == "Cob" && !gen_no_client_completion_) { 
+            out << indent() << "  completed = true;" << endl << indent() << "  completed__(true);" 
+                << endl; 
+          } 
+          if (style == "Concurrent") { 
+            out << indent() << "  sentry.commit();" << endl; 
+          } 
+          out << indent() << "  throw result." << (*x_iter)->get_name() << ";" << endl << indent() 
+              << "}" << endl; 
+        } 
+ 
+        // We only get here if we are a void function 
+        if ((*f_iter)->get_returntype()->is_void()) { 
+          if (style == "Cob" && !gen_no_client_completion_) { 
+            out << indent() << "completed = true;" << endl << indent() << "completed__(true);" 
+                << endl; 
+          } 
+          if (style == "Concurrent") { 
+            out << indent() << "sentry.commit();" << endl; 
+          } 
+          indent(out) << "return;" << endl; 
+        } else { 
+          if (style == "Cob" && !gen_no_client_completion_) { 
+            out << indent() << "completed = true;" << endl << indent() << "completed__(true);" 
+                << endl; 
+          } 
+          if (style == "Concurrent") { 
+            out << indent() << "// in a bad state, don't commit" << endl; 
+          } 
+          out << indent() << "throw " 
+                             "::apache::thrift::TApplicationException(::apache::thrift::" 
+                             "TApplicationException::MISSING_RESULT, \"" << (*f_iter)->get_name() 
+              << " failed: unknown result\");" << endl; 
+        } 
+        if (style == "Concurrent") { 
+          indent_down(); 
+          indent_down(); 
+          out << 
+            indent() << "  }" << endl << 
+            indent() << "  // seqid != rseqid" << endl << 
+            indent() << "  this->sync_.updatePending(fname, mtype, rseqid);" << endl << 
+            endl << 
+            indent() << "  // this will temporarily unlock the readMutex, and let other clients get work done" << endl << 
+            indent() << "  this->sync_.waitForWork(seqid);" << endl << 
+            indent() << "} // end while(true)" << endl; 
+        } 
+        if (style == "Cob" && !gen_no_client_completion_) { 
+          indent_down(); 
+          out << indent() << "} catch (...) {" << endl << indent() << "  if (!completed) {" << endl 
+              << indent() << "    completed__(false);" << endl << indent() << "  }" << endl 
+              << indent() << "  throw;" << endl << indent() << "}" << endl; 
+        } 
+        // Close function 
+        scope_down(out); 
+        out << endl; 
+      } 
+    } 
+  } 
+} 
+ 
+class ProcessorGenerator { 
+public: 
+  ProcessorGenerator(t_cpp_generator* generator, t_service* service, const string& style); 
+ 
+  void run() { 
+    generate_class_definition(); 
+ 
+    // Generate the dispatchCall() function 
+    generate_dispatch_call(false); 
+    if (generator_->gen_templates_) { 
+      generate_dispatch_call(true); 
+    } 
+ 
+    // Generate all of the process subfunctions 
+    generate_process_functions(); 
+ 
+    generate_factory(); 
+  } 
+ 
+  void generate_class_definition(); 
+  void generate_dispatch_call(bool template_protocol); 
+  void generate_process_functions(); 
+  void generate_factory(); 
+ 
+protected: 
+  std::string type_name(t_type* ttype, bool in_typedef = false, bool arg = false) { 
+    return generator_->type_name(ttype, in_typedef, arg); 
+  } 
+ 
+  std::string indent() { return generator_->indent(); } 
+  std::ostream& indent(std::ostream& os) { return generator_->indent(os); } 
+ 
+  void indent_up() { generator_->indent_up(); } 
+  void indent_down() { generator_->indent_down(); } 
+ 
+  t_cpp_generator* generator_; 
+  t_service* service_; 
+  std::ostream& f_header_; 
+  std::ostream& f_out_; 
+  string service_name_; 
+  string style_; 
+  string pstyle_; 
+  string class_name_; 
+  string if_name_; 
+  string factory_class_name_; 
+  string finish_cob_; 
+  string finish_cob_decl_; 
+  string ret_type_; 
+  string call_context_; 
+  string cob_arg_; 
+  string call_context_arg_; 
+  string call_context_decl_; 
+  string template_header_; 
+  string template_suffix_; 
+  string typename_str_; 
+  string class_suffix_; 
+  string extends_; 
+}; 
+ 
+ProcessorGenerator::ProcessorGenerator(t_cpp_generator* generator, 
+                                       t_service* service, 
+                                       const string& style) 
+  : generator_(generator), 
+    service_(service), 
+    f_header_(generator->f_header_), 
+    f_out_(generator->gen_templates_ ? generator->f_service_tcc_ : generator->f_service_), 
+    service_name_(generator->service_name_), 
+    style_(style) { 
+  if (style_ == "Cob") { 
+    pstyle_ = "Async"; 
+    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)>, "; 
+    cob_arg_ = "cob, "; 
+    ret_type_ = "void "; 
+  } else { 
+    class_name_ = service_name_ + "Processor"; 
+    if_name_ = service_name_ + "If"; 
+ 
+    ret_type_ = "bool "; 
+    // TODO(edhall) callContext should eventually be added to TAsyncProcessor 
+    call_context_ = ", void* callContext"; 
+    call_context_arg_ = ", callContext"; 
+    call_context_decl_ = ", void*"; 
+  } 
+ 
+  factory_class_name_ = class_name_ + "Factory"; 
+ 
+  if (generator->gen_templates_) { 
+    template_header_ = "template <class Protocol_>\n"; 
+    template_suffix_ = "<Protocol_>"; 
+    typename_str_ = "typename "; 
+    class_name_ += "T"; 
+    factory_class_name_ += "T"; 
+  } 
+ 
+  if (service_->get_extends() != NULL) { 
+    extends_ = type_name(service_->get_extends()) + pstyle_ + "Processor"; 
+    if (generator_->gen_templates_) { 
+      // TODO(simpkins): If gen_templates_ is enabled, we currently assume all 
+      // parent services were also generated with templates enabled. 
+      extends_ += "T<Protocol_>"; 
+    } 
+  } 
+} 
+ 
+void ProcessorGenerator::generate_class_definition() { 
+  // Generate the dispatch methods 
+  vector<t_function*> functions = service_->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+ 
+  string parent_class; 
+  if (service_->get_extends() != NULL) { 
+    parent_class = extends_; 
+  } else { 
+    if (style_ == "Cob") { 
+      parent_class = "::apache::thrift::async::TAsyncDispatchProcessor"; 
+    } else { 
+      parent_class = "::apache::thrift::TDispatchProcessor"; 
+    } 
+ 
+    if (generator_->gen_templates_) { 
+      parent_class += "T<Protocol_>"; 
+    } 
+  } 
+ 
+  // Generate the header portion 
+  f_header_ << template_header_ << "class " << class_name_ << " : public " << parent_class << " {" 
+            << endl; 
+ 
+  // Protected data members 
+  f_header_ << " protected:" << endl; 
+  indent_up(); 
+  f_header_ << indent() << "::apache::thrift::stdcxx::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, " 
+            << "const std::string& fname, int32_t seqid" << call_context_ << ");" << endl; 
+  if (generator_->gen_templates_) { 
+    f_header_ << indent() << "virtual " << ret_type_ << "dispatchCallTemplated(" << finish_cob_ 
+              << "Protocol_* iprot, Protocol_* oprot, " 
+              << "const std::string& fname, int32_t seqid" << call_context_ << ");" << endl; 
+  } 
+  indent_down(); 
+ 
+  // Process function declarations 
+  f_header_ << " private:" << endl; 
+  indent_up(); 
+ 
+  // Declare processMap_ 
+  f_header_ << indent() << "typedef  void (" << class_name_ << "::*" 
+            << "ProcessFunction)(" << finish_cob_decl_ << "int32_t, " 
+            << "::apache::thrift::protocol::TProtocol*, " 
+            << "::apache::thrift::protocol::TProtocol*" << call_context_decl_ << ");" << endl; 
+  if (generator_->gen_templates_) { 
+    f_header_ << indent() << "typedef void (" << class_name_ << "::*" 
+              << "SpecializedProcessFunction)(" << finish_cob_decl_ << "int32_t, " 
+              << "Protocol_*, Protocol_*" << call_context_decl_ << ");" << endl << indent() 
+              << "struct ProcessFunctions {" << endl << indent() << "  ProcessFunction generic;" 
+              << endl << indent() << "  SpecializedProcessFunction specialized;" << endl << indent() 
+              << "  ProcessFunctions(ProcessFunction g, " 
+              << "SpecializedProcessFunction s) :" << endl << indent() << "    generic(g)," << endl 
+              << indent() << "    specialized(s) {}" << endl << indent() 
+              << "  ProcessFunctions() : generic(NULL), specialized(NULL) " 
+              << "{}" << endl << indent() << "};" << endl << indent() 
+              << "typedef std::map<std::string, ProcessFunctions> " 
+              << "ProcessMap;" << endl; 
+  } else { 
+    f_header_ << indent() << "typedef std::map<std::string, ProcessFunction> " 
+              << "ProcessMap;" << endl; 
+  } 
+  f_header_ << indent() << "ProcessMap processMap_;" << endl; 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    indent(f_header_) << "void process_" << (*f_iter)->get_name() << "(" << finish_cob_ 
+                      << "int32_t seqid, ::apache::thrift::protocol::TProtocol* iprot, " 
+                         "::apache::thrift::protocol::TProtocol* oprot" << call_context_ << ");" 
+                      << endl; 
+    if (generator_->gen_templates_) { 
+      indent(f_header_) << "void process_" << (*f_iter)->get_name() << "(" << finish_cob_ 
+                        << "int32_t seqid, Protocol_* iprot, Protocol_* oprot" << call_context_ 
+                        << ");" << endl; 
+    } 
+    if (style_ == "Cob") { 
+      // XXX Factor this out, even if it is a pain. 
+      string ret_arg = ((*f_iter)->get_returntype()->is_void() 
+                            ? "" 
+                            : ", 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, " 
+                << "::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, " 
+                  << "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, " 
+                << "::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, " 
+                  << "Protocol_* oprot, void* ctx, " 
+                  << "::apache::thrift::TDelayedException* _throw);" << endl; 
+      } 
+    } 
+  } 
+ 
+  f_header_ << " public:" << endl << indent() << class_name_ << "(::apache::thrift::stdcxx::shared_ptr<" << if_name_ 
+            << "> iface) :" << endl; 
+  if (!extends_.empty()) { 
+    f_header_ << indent() << "  " << extends_ << "(iface)," << endl; 
+  } 
+  f_header_ << indent() << "  iface_(iface) {" << endl; 
+  indent_up(); 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    f_header_ << indent() << "processMap_[\"" << (*f_iter)->get_name() << "\"] = "; 
+    if (generator_->gen_templates_) { 
+      f_header_ << "ProcessFunctions(" << endl; 
+      if (generator_->gen_templates_only_) { 
+        indent(f_header_) << "  NULL," << endl; 
+      } else { 
+        indent(f_header_) << "  &" << class_name_ << "::process_" << (*f_iter)->get_name() << "," 
+                          << endl; 
+      } 
+      indent(f_header_) << "  &" << class_name_ << "::process_" << (*f_iter)->get_name() << ")"; 
+    } else { 
+      f_header_ << "&" << class_name_ << "::process_" << (*f_iter)->get_name(); 
+    } 
+    f_header_ << ";" << endl; 
+  } 
+ 
+  indent_down(); 
+  f_header_ << indent() << "}" << endl << endl << indent() << "virtual ~" << class_name_ << "() {}" 
+            << endl; 
+  indent_down(); 
+  f_header_ << "};" << endl << endl; 
+ 
+  if (generator_->gen_templates_) { 
+    // Generate a backwards compatible typedef, for callers who don't know 
+    // about the new template-style code. 
+    // 
+    // We can't use TProtocol as the template parameter, since ProcessorT 
+    // provides overloaded versions of most methods, one of which accepts 
+    // TProtocol pointers, and one which accepts Protocol_ pointers.  This 
+    // results in a compile error if instantiated with Protocol_ == TProtocol. 
+    // Therefore, we define TDummyProtocol solely so we can use it as the 
+    // template parameter here. 
+    f_header_ << "typedef " << class_name_ << "< ::apache::thrift::protocol::TDummyProtocol > " 
+              << service_name_ << pstyle_ << "Processor;" << endl << endl; 
+  } 
+} 
+ 
+void ProcessorGenerator::generate_dispatch_call(bool template_protocol) { 
+  string protocol = "::apache::thrift::protocol::TProtocol"; 
+  string function_suffix; 
+  if (template_protocol) { 
+    protocol = "Protocol_"; 
+    // We call the generic version dispatchCall(), and the specialized 
+    // version dispatchCallTemplated().  We can't call them both 
+    // dispatchCall(), since this will cause the compiler to issue a warning if 
+    // a service that doesn't use templates inherits from a service that does 
+    // use templates: the compiler complains that the subclass only implements 
+    // the generic version of dispatchCall(), and hides the templated version. 
+    // Using different names for the two functions prevents this. 
+    function_suffix = "Templated"; 
+  } 
+ 
+  f_out_ << template_header_ << ret_type_ << class_name_ << template_suffix_ << "::dispatchCall" 
+         << function_suffix << "(" << finish_cob_ << protocol << "* iprot, " << protocol 
+         << "* oprot, " 
+         << "const std::string& fname, int32_t seqid" << call_context_ << ") {" << endl; 
+  indent_up(); 
+ 
+  // HOT: member function pointer map 
+  f_out_ << indent() << typename_str_ << "ProcessMap::iterator pfn;" << endl << indent() 
+         << "pfn = processMap_.find(fname);" << endl << indent() 
+         << "if (pfn == processMap_.end()) {" << endl; 
+  if (extends_.empty()) { 
+    f_out_ << indent() << "  iprot->skip(::apache::thrift::protocol::T_STRUCT);" << endl << indent() 
+           << "  iprot->readMessageEnd();" << endl << indent() 
+           << "  iprot->getTransport()->readEnd();" << endl << indent() 
+           << "  ::apache::thrift::TApplicationException " 
+              "x(::apache::thrift::TApplicationException::UNKNOWN_METHOD, \"Invalid method name: " 
+              "'\"+fname+\"'\");" << endl << indent() 
+           << "  oprot->writeMessageBegin(fname, ::apache::thrift::protocol::T_EXCEPTION, seqid);" 
+           << endl << indent() << "  x.write(oprot);" << endl << indent() 
+           << "  oprot->writeMessageEnd();" << endl << indent() 
+           << "  oprot->getTransport()->writeEnd();" << endl << indent() 
+           << "  oprot->getTransport()->flush();" << endl << indent() 
+           << (style_ == "Cob" ? "  return cob(true);" : "  return true;") << endl; 
+  } else { 
+    f_out_ << indent() << "  return " << extends_ << "::dispatchCall(" 
+           << (style_ == "Cob" ? "cob, " : "") << "iprot, oprot, fname, seqid" << call_context_arg_ 
+           << ");" << endl; 
+  } 
+  f_out_ << indent() << "}" << endl; 
+  if (template_protocol) { 
+    f_out_ << indent() << "(this->*(pfn->second.specialized))"; 
+  } else { 
+    if (generator_->gen_templates_only_) { 
+      // TODO: This is a null pointer, so nothing good will come from calling 
+      // it.  Throw an exception instead. 
+      f_out_ << indent() << "(this->*(pfn->second.generic))"; 
+    } else if (generator_->gen_templates_) { 
+      f_out_ << indent() << "(this->*(pfn->second.generic))"; 
+    } else { 
+      f_out_ << indent() << "(this->*(pfn->second))"; 
+    } 
+  } 
+  f_out_ << "(" << cob_arg_ << "seqid, iprot, oprot" << call_context_arg_ << ");" << endl; 
+ 
+  // TODO(dreiss): return pfn ret? 
+  if (style_ == "Cob") { 
+    f_out_ << indent() << "return;" << endl; 
+  } else { 
+    f_out_ << indent() << "return true;" << endl; 
+  } 
+ 
+  indent_down(); 
+  f_out_ << "}" << endl << endl; 
+} 
+ 
+void ProcessorGenerator::generate_process_functions() { 
+  vector<t_function*> functions = service_->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    if (generator_->gen_templates_) { 
+      generator_->generate_process_function(service_, *f_iter, style_, false); 
+      generator_->generate_process_function(service_, *f_iter, style_, true); 
+    } else { 
+      generator_->generate_process_function(service_, *f_iter, style_, false); 
+    } 
+  } 
+} 
+ 
+void ProcessorGenerator::generate_factory() { 
+  string if_factory_name = if_name_ + "Factory"; 
+ 
+  // Generate the factory class definition 
+  f_header_ << template_header_ << "class " << factory_class_name_ << " : public ::apache::thrift::" 
+            << (style_ == "Cob" ? "async::TAsyncProcessorFactory" : "TProcessorFactory") << " {" 
+            << endl << " public:" << endl; 
+  indent_up(); 
+ 
+  f_header_ << indent() << factory_class_name_ << "(const ::apache::thrift::stdcxx::shared_ptr< " << if_factory_name 
+            << " >& handlerFactory) :" << endl << indent() 
+            << "    handlerFactory_(handlerFactory) {}" << endl << endl << indent() 
+            << "::apache::thrift::stdcxx::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< " 
+            << if_factory_name << " > handlerFactory_;" << endl; 
+ 
+  indent_down(); 
+  f_header_ << "};" << endl << endl; 
+ 
+  // If we are generating templates, output a typedef for the plain 
+  // factory name. 
+  if (generator_->gen_templates_) { 
+    f_header_ << "typedef " << factory_class_name_ 
+              << "< ::apache::thrift::protocol::TDummyProtocol > " << service_name_ << pstyle_ 
+              << "ProcessorFactory;" << endl << endl; 
+  } 
+ 
+  // Generate the getProcessor() method 
+  f_out_ << template_header_ << indent() << "::apache::thrift::stdcxx::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< " 
+         << if_name_ << " > handler(" 
+         << "handlerFactory_->getHandler(connInfo), cleanup);" << endl << indent() 
+         << "::apache::thrift::stdcxx::shared_ptr< ::apache::thrift::" 
+         << (style_ == "Cob" ? "async::TAsyncProcessor" : "TProcessor") << " > " 
+         << "processor(new " << class_name_ << template_suffix_ << "(handler));" << endl << indent() 
+         << "return processor;" << endl; 
+ 
+  indent_down(); 
+  f_out_ << indent() << "}" << endl << endl; 
+} 
+ 
+/** 
+ * Generates a service processor definition. 
+ * 
+ * @param tservice The service to generate a processor for. 
+ */ 
+void t_cpp_generator::generate_service_processor(t_service* tservice, string style) { 
+  ProcessorGenerator generator(this, tservice, style); 
+  generator.run(); 
+} 
+ 
+/** 
+ * Generates a struct and helpers for a function. 
+ * 
+ * @param tfunction The function 
+ */ 
+void t_cpp_generator::generate_function_helpers(t_service* tservice, t_function* tfunction) { 
+  if (tfunction->is_oneway()) { 
+    return; 
+  } 
+ 
+  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_); 
+ 
+  t_struct result(program_, tservice->get_name() + "_" + tfunction->get_name() + "_result"); 
+  t_field success(tfunction->get_returntype(), "success", 0); 
+  if (!tfunction->get_returntype()->is_void()) { 
+    result.append(&success); 
+  } 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const vector<t_field*>& fields = xs->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    result.append(*f_iter); 
+  } 
+ 
+  generate_struct_declaration(f_header_, &result, false); 
+  generate_struct_definition(out, f_service_, &result, false); 
+  generate_struct_reader(out, &result); 
+  generate_struct_result_writer(out, &result); 
+ 
+  result.set_name(tservice->get_name() + "_" + tfunction->get_name() + "_presult"); 
+  generate_struct_declaration(f_header_, &result, false, true, true, gen_cob_style_); 
+  generate_struct_definition(out, f_service_, &result, false); 
+  generate_struct_reader(out, &result, true); 
+  if (gen_cob_style_) { 
+    generate_struct_writer(out, &result, true); 
+  } 
+} 
+ 
+/** 
+ * Generates a process function definition. 
+ * 
+ * @param tfunction The function to write a dispatcher for 
+ */ 
+void t_cpp_generator::generate_process_function(t_service* tservice, 
+                                                t_function* tfunction, 
+                                                string style, 
+                                                bool specialized) { 
+  t_struct* arg_struct = tfunction->get_arglist(); 
+  const std::vector<t_field*>& fields = arg_struct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const std::vector<t_field*>& xceptions = xs->get_members(); 
+  vector<t_field*>::const_iterator x_iter; 
+  string service_func_name = "\"" + tservice->get_name() + "." + tfunction->get_name() + "\""; 
+ 
+  std::ostream& out = (gen_templates_ ? f_service_tcc_ : f_service_); 
+ 
+  string prot_type = (specialized ? "Protocol_" : "::apache::thrift::protocol::TProtocol"); 
+  string class_suffix; 
+  if (gen_templates_) { 
+    class_suffix = "T<Protocol_>"; 
+  } 
+ 
+  // I tried to do this as one function.  I really did.  But it was too hard. 
+  if (style != "Cob") { 
+    // Open function 
+    if (gen_templates_) { 
+      out << indent() << "template <class Protocol_>" << endl; 
+    } 
+    const bool unnamed_oprot_seqid = tfunction->is_oneway() && !(gen_templates_ && !specialized); 
+    out << "void " << tservice->get_name() << "Processor" << class_suffix << "::" 
+        << "process_" << tfunction->get_name() << "(" 
+        << "int32_t" << (unnamed_oprot_seqid ? ", " : " seqid, ") << prot_type << "* iprot, " 
+        << prot_type << "*" << (unnamed_oprot_seqid ? ", " : " oprot, ") << "void* callContext)" 
+        << endl; 
+    scope_up(out); 
+ 
+    string argsname = tservice->get_name() + "_" + tfunction->get_name() + "_args"; 
+    string resultname = tservice->get_name() + "_" + tfunction->get_name() + "_result"; 
+ 
+    if (tfunction->is_oneway() && !unnamed_oprot_seqid) { 
+      out << indent() << "(void) seqid;" << endl << indent() << "(void) oprot;" << endl; 
+    } 
+ 
+    out << indent() << "void* ctx = NULL;" << endl << indent() 
+        << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", callContext);" 
+        << endl << indent() << "}" << endl << indent() 
+        << "::apache::thrift::TProcessorContextFreer freer(" 
+        << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl 
+        << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  this->eventHandler_->preRead(ctx, " << service_func_name << ");" << endl << indent() 
+        << "}" << endl << endl << indent() << argsname << " args;" << endl << indent() 
+        << "args.read(iprot);" << endl << indent() << "iprot->readMessageEnd();" << endl << indent() 
+        << "uint32_t bytes = iprot->getTransport()->readEnd();" << endl << endl << indent() 
+        << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  this->eventHandler_->postRead(ctx, " << service_func_name << ", bytes);" << endl 
+        << indent() << "}" << endl << endl; 
+ 
+    // Declare result 
+    if (!tfunction->is_oneway()) { 
+      out << indent() << resultname << " result;" << endl; 
+    } 
+ 
+    // Try block for functions with exceptions 
+    out << indent() << "try {" << endl; 
+    indent_up(); 
+ 
+    // Generate the function call 
+    bool first = true; 
+    out << indent(); 
+    if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) { 
+      if (is_complex_type(tfunction->get_returntype())) { 
+        first = false; 
+        out << "iface_->" << tfunction->get_name() << "(result.success"; 
+      } else { 
+        out << "result.success = iface_->" << tfunction->get_name() << "("; 
+      } 
+    } else { 
+      out << "iface_->" << tfunction->get_name() << "("; 
+    } 
+    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+      if (first) { 
+        first = false; 
+      } else { 
+        out << ", "; 
+      } 
+      out << "args." << (*f_iter)->get_name(); 
+    } 
+    out << ");" << endl; 
+ 
+    // Set isset on success field 
+    if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) { 
+      out << indent() << "result.__isset.success = true;" << endl; 
+    } 
+ 
+    indent_down(); 
+    out << indent() << "}"; 
+ 
+    if (!tfunction->is_oneway()) { 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+        out << " catch (" << type_name((*x_iter)->get_type()) << " &" << (*x_iter)->get_name() 
+            << ") {" << endl; 
+        if (!tfunction->is_oneway()) { 
+          indent_up(); 
+          out << indent() << "result." << (*x_iter)->get_name() << " = " << (*x_iter)->get_name() 
+              << ";" << endl << indent() << "result.__isset." << (*x_iter)->get_name() << " = true;" 
+              << endl; 
+          indent_down(); 
+          out << indent() << "}"; 
+        } else { 
+          out << "}"; 
+        } 
+      } 
+    } 
+ 
+    if (!tfunction->is_oneway()) { 
+      out << " catch (const std::exception& e) {" << endl; 
+    } else { 
+      out << " catch (const std::exception&) {" << endl; 
+    } 
+ 
+    indent_up(); 
+    out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  this->eventHandler_->handlerError(ctx, " << service_func_name << ");" << endl 
+        << indent() << "}" << endl; 
+ 
+    if (!tfunction->is_oneway()) { 
+      out << endl << indent() << "::apache::thrift::TApplicationException x(e.what());" << endl 
+          << indent() << "oprot->writeMessageBegin(\"" << tfunction->get_name() 
+          << "\", ::apache::thrift::protocol::T_EXCEPTION, seqid);" << endl << indent() 
+          << "x.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" << endl 
+          << indent() << "oprot->getTransport()->writeEnd();" << endl << indent() 
+          << "oprot->getTransport()->flush();" << endl; 
+    } 
+    out << indent() << "return;" << endl; 
+    indent_down(); 
+    out << indent() << "}" << endl << endl; 
+ 
+    // Shortcut out here for oneway functions 
+    if (tfunction->is_oneway()) { 
+      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  this->eventHandler_->asyncComplete(ctx, " << service_func_name << ");" << endl 
+          << indent() << "}" << endl << endl << indent() << "return;" << endl; 
+      indent_down(); 
+      out << "}" << endl << endl; 
+      return; 
+    } 
+ 
+    // Serialize the result into a struct 
+    out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  this->eventHandler_->preWrite(ctx, " << service_func_name << ");" << endl << indent() 
+        << "}" << endl << endl << indent() << "oprot->writeMessageBegin(\"" << tfunction->get_name() 
+        << "\", ::apache::thrift::protocol::T_REPLY, seqid);" << endl << indent() 
+        << "result.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" << endl 
+        << indent() << "bytes = oprot->getTransport()->writeEnd();" << endl << indent() 
+        << "oprot->getTransport()->flush();" << endl << endl << indent() 
+        << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  this->eventHandler_->postWrite(ctx, " << service_func_name << ", bytes);" << endl 
+        << indent() << "}" << endl; 
+ 
+    // Close function 
+    scope_down(out); 
+    out << endl; 
+  } 
+ 
+  // Cob style. 
+  else { 
+    // Processor entry point. 
+    // TODO(edhall) update for callContext when TEventServer is ready 
+    if (gen_templates_) { 
+      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, " 
+        << prot_type << "* iprot, " << prot_type << "* oprot)" << endl; 
+    scope_up(out); 
+ 
+    // TODO(simpkins): we could try to consoldate this 
+    // with the non-cob code above 
+    if (gen_templates_ && !specialized) { 
+      // If these are instances of Protocol_, instead of any old TProtocol, 
+      // use the specialized process function instead. 
+      out << indent() << "Protocol_* _iprot = dynamic_cast<Protocol_*>(iprot);" << endl << indent() 
+          << "Protocol_* _oprot = dynamic_cast<Protocol_*>(oprot);" << endl << indent() 
+          << "if (_iprot && _oprot) {" << endl << indent() << "  return process_" 
+          << tfunction->get_name() << "(cob, seqid, _iprot, _oprot);" << endl << indent() << "}" 
+          << endl << indent() << "T_GENERIC_PROTOCOL(this, iprot, _iprot);" << endl << indent() 
+          << "T_GENERIC_PROTOCOL(this, oprot, _oprot);" << endl << endl; 
+    } 
+ 
+    if (tfunction->is_oneway()) { 
+      out << indent() << "(void) seqid;" << endl << indent() << "(void) oprot;" << endl; 
+    } 
+ 
+    out << indent() << tservice->get_name() + "_" + tfunction->get_name() << "_args args;" << endl 
+        << indent() << "void* ctx = NULL;" << endl << indent() 
+        << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", NULL);" << endl 
+        << indent() << "}" << endl << indent() << "::apache::thrift::TProcessorContextFreer freer(" 
+        << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl 
+        << indent() << "try {" << endl; 
+    indent_up(); 
+    out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  this->eventHandler_->preRead(ctx, " << service_func_name << ");" << endl << indent() 
+        << "}" << endl << indent() << "args.read(iprot);" << endl << indent() 
+        << "iprot->readMessageEnd();" << endl << indent() 
+        << "uint32_t bytes = iprot->getTransport()->readEnd();" << endl << indent() 
+        << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "  this->eventHandler_->postRead(ctx, " << service_func_name << ", bytes);" << endl 
+        << indent() << "}" << endl; 
+    scope_down(out); 
+ 
+    // TODO(dreiss): Handle TExceptions?  Expose to server? 
+    out << indent() << "catch (const std::exception&) {" << endl << indent() 
+        << "  if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+        << "    this->eventHandler_->handlerError(ctx, " << service_func_name << ");" << endl 
+        << indent() << "  }" << endl << indent() << "  return cob(false);" << endl << indent() 
+        << "}" << endl; 
+ 
+    if (tfunction->is_oneway()) { 
+      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  this->eventHandler_->asyncComplete(ctx, " << service_func_name << ");" << endl 
+          << indent() << "}" << endl; 
+    } 
+    // TODO(dreiss): Figure out a strategy for exceptions in async handlers. 
+    out << indent() << "freer.unregister();" << endl; 
+    if (tfunction->is_oneway()) { 
+      // 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; 
+      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"; 
+      } 
+ 
+      // 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)> " 
+          << "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)> " 
+            << "cob, int32_t seqid, " << prot_type << "* oprot, void* ctx, " 
+            << "::apache::thrift::TDelayedException* _throw) =" << endl; 
+        out << indent() << "  &" << tservice->get_name() << "AsyncProcessor" << class_suffix 
+            << "::throw_" << tfunction->get_name() << ";" << endl; 
+      } 
+ 
+      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 
+          << ")"; 
+      if (!xceptions.empty()) { 
+        out << ',' << endl << indent() << "::apache::thrift::stdcxx::bind(throw_fn, this, cob, seqid, oprot, " 
+            << "ctx, ::apache::thrift::stdcxx::placeholders::_1)"; 
+      } 
+    } 
+ 
+    // XXX Whitespace cleanup. 
+    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+      out << ',' << endl << indent() << "args." << (*f_iter)->get_name(); 
+    } 
+    out << ");" << endl; 
+    indent_down(); 
+    indent_down(); 
+    scope_down(out); 
+    out << endl; 
+ 
+    // Normal return. 
+    if (!tfunction->is_oneway()) { 
+      string ret_arg_decl, ret_arg_name; 
+      if (!tfunction->get_returntype()->is_void()) { 
+        ret_arg_decl = ", const " + type_name(tfunction->get_returntype()) + "& _return"; 
+        ret_arg_name = ", _return"; 
+      } 
+      if (gen_templates_) { 
+        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, " 
+          << prot_type << "* oprot, void* ctx" << ret_arg_decl << ')' << endl; 
+      scope_up(out); 
+ 
+      if (gen_templates_ && !specialized) { 
+        // If oprot is a Protocol_ instance, 
+        // use the specialized return function instead. 
+        out << indent() << "Protocol_* _oprot = dynamic_cast<Protocol_*>(oprot);" << endl 
+            << indent() << "if (_oprot) {" << endl << indent() << "  return return_" 
+            << tfunction->get_name() << "(cob, seqid, _oprot, ctx" << ret_arg_name << ");" << endl 
+            << indent() << "}" << endl << indent() << "T_GENERIC_PROTOCOL(this, oprot, _oprot);" 
+            << endl << endl; 
+      } 
+ 
+      out << indent() << tservice->get_name() << "_" << tfunction->get_name() << "_presult result;" 
+          << endl; 
+      if (!tfunction->get_returntype()->is_void()) { 
+        // The const_cast here is unfortunate, but it would be a pain to avoid, 
+        // and we only do a write with this struct, which is const-safe. 
+        out << indent() << "result.success = const_cast<" << type_name(tfunction->get_returntype()) 
+            << "*>(&_return);" << endl << indent() << "result.__isset.success = true;" << endl; 
+      } 
+      // Serialize the result into a struct 
+      out << endl << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", NULL);" << endl 
+          << indent() << "}" << endl << indent() 
+          << "::apache::thrift::TProcessorContextFreer freer(" 
+          << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl 
+          << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  this->eventHandler_->preWrite(ctx, " << service_func_name << ");" << endl 
+          << indent() << "}" << endl << endl << indent() << "oprot->writeMessageBegin(\"" 
+          << tfunction->get_name() << "\", ::apache::thrift::protocol::T_REPLY, seqid);" << endl 
+          << indent() << "result.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" 
+          << endl << indent() << "uint32_t bytes = oprot->getTransport()->writeEnd();" << endl 
+          << indent() << "oprot->getTransport()->flush();" << endl << indent() 
+          << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  this->eventHandler_->postWrite(ctx, " << service_func_name << ", bytes);" << endl 
+          << indent() << "}" << endl << indent() << "return cob(true);" << endl; 
+      scope_down(out); 
+      out << endl; 
+    } 
+ 
+    // Exception return. 
+    if (!tfunction->is_oneway() && !xceptions.empty()) { 
+      if (gen_templates_) { 
+        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, " 
+          << prot_type << "* oprot, void* ctx, " 
+          << "::apache::thrift::TDelayedException* _throw)" << endl; 
+      scope_up(out); 
+ 
+      if (gen_templates_ && !specialized) { 
+        // If oprot is a Protocol_ instance, 
+        // use the specialized throw function instead. 
+        out << indent() << "Protocol_* _oprot = dynamic_cast<Protocol_*>(oprot);" << endl 
+            << indent() << "if (_oprot) {" << endl << indent() << "  return throw_" 
+            << tfunction->get_name() << "(cob, seqid, _oprot, ctx, _throw);" << endl << indent() 
+            << "}" << endl << indent() << "T_GENERIC_PROTOCOL(this, oprot, _oprot);" << endl 
+            << endl; 
+      } 
+ 
+      // Get the event handler context 
+      out << endl << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  ctx = this->eventHandler_->getContext(" << service_func_name << ", NULL);" << endl 
+          << indent() << "}" << endl << indent() 
+          << "::apache::thrift::TProcessorContextFreer freer(" 
+          << "this->eventHandler_.get(), ctx, " << service_func_name << ");" << endl << endl; 
+ 
+      // Throw the TDelayedException, and catch the result 
+      out << indent() << tservice->get_name() << "_" << tfunction->get_name() << "_result result;" 
+          << endl << endl << indent() << "try {" << endl; 
+      indent_up(); 
+      out << indent() << "_throw->throw_it();" << endl << indent() << "return cob(false);" 
+          << endl; // Is this possible?  TBD. 
+      indent_down(); 
+      out << indent() << '}'; 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+        out << "  catch (" << type_name((*x_iter)->get_type()) << " &" << (*x_iter)->get_name() 
+            << ") {" << endl; 
+        indent_up(); 
+        out << indent() << "result." << (*x_iter)->get_name() << " = " << (*x_iter)->get_name() 
+            << ";" << endl << indent() << "result.__isset." << (*x_iter)->get_name() << " = true;" 
+            << endl; 
+        scope_down(out); 
+      } 
+ 
+      // Handle the case where an undeclared exception is thrown 
+      out << " catch (std::exception& e) {" << endl; 
+      indent_up(); 
+      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  this->eventHandler_->handlerError(ctx, " << service_func_name << ");" << endl 
+          << indent() << "}" << endl << endl << indent() 
+          << "::apache::thrift::TApplicationException x(e.what());" << endl << indent() 
+          << "oprot->writeMessageBegin(\"" << tfunction->get_name() 
+          << "\", ::apache::thrift::protocol::T_EXCEPTION, seqid);" << endl << indent() 
+          << "x.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" << endl 
+          << indent() << "oprot->getTransport()->writeEnd();" << endl << indent() 
+          << "oprot->getTransport()->flush();" << endl << 
+          // We pass true to the cob here, since we did successfully write a 
+          // response, even though it is an exception response. 
+          // It looks like the argument is currently ignored, anyway. 
+          indent() << "return cob(true);" << endl; 
+      scope_down(out); 
+ 
+      // Serialize the result into a struct 
+      out << indent() << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  this->eventHandler_->preWrite(ctx, " << service_func_name << ");" << endl 
+          << indent() << "}" << endl << endl << indent() << "oprot->writeMessageBegin(\"" 
+          << tfunction->get_name() << "\", ::apache::thrift::protocol::T_REPLY, seqid);" << endl 
+          << indent() << "result.write(oprot);" << endl << indent() << "oprot->writeMessageEnd();" 
+          << endl << indent() << "uint32_t bytes = oprot->getTransport()->writeEnd();" << endl 
+          << indent() << "oprot->getTransport()->flush();" << endl << indent() 
+          << "if (this->eventHandler_.get() != NULL) {" << endl << indent() 
+          << "  this->eventHandler_->postWrite(ctx, " << service_func_name << ", bytes);" << endl 
+          << indent() << "}" << endl << indent() << "return cob(true);" << endl; 
+      scope_down(out); 
+      out << endl; 
+    } // for each function 
+  }   // cob style 
+} 
+ 
+/** 
+ * Generates a skeleton file of a server 
+ * 
+ * @param tservice The service to generate a server for. 
+ */ 
+void t_cpp_generator::generate_service_skeleton(t_service* tservice) { 
+  string svcname = tservice->get_name(); 
+ 
+  // Service implementation file includes 
+  string f_skeleton_name = get_out_dir() + svcname + "_server.skeleton.cpp"; 
+ 
+  string ns = namespace_prefix(tservice->get_program()->get_namespace("cpp")); 
+ 
+  ofstream_with_content_based_conditional_update f_skeleton; 
+  f_skeleton.open(f_skeleton_name.c_str()); 
+  f_skeleton << "// This autogenerated skeleton file illustrates how to build a server." << endl 
+             << "// You should copy it to another filename to avoid overwriting it." << endl << endl 
+             << "#include \"" << get_include_prefix(*get_program()) << svcname << ".h\"" << endl 
+             << "#include <thrift/protocol/TBinaryProtocol.h>" << endl 
+             << "#include <thrift/server/TSimpleServer.h>" << endl 
+             << "#include <thrift/transport/TServerSocket.h>" << endl 
+             << "#include <thrift/transport/TBufferTransports.h>" << endl << endl 
+             << "using namespace ::apache::thrift;" << endl 
+             << "using namespace ::apache::thrift::protocol;" << endl 
+             << "using namespace ::apache::thrift::transport;" << endl 
+             << "using namespace ::apache::thrift::server;" << endl << endl; 
+ 
+  // the following code would not compile: 
+  // using namespace ; 
+  // using namespace ::; 
+  if ((!ns.empty()) && (ns.compare(" ::") != 0)) { 
+    f_skeleton << "using namespace " << string(ns, 0, ns.size() - 2) << ";" << endl << endl; 
+  } 
+ 
+  f_skeleton << "class " << svcname << "Handler : virtual public " << svcname << "If {" << endl 
+             << " public:" << endl; 
+  indent_up(); 
+  f_skeleton << indent() << svcname << "Handler() {" << endl << indent() 
+             << "  // Your initialization goes here" << endl << indent() << "}" << endl << endl; 
+ 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_java_doc(f_skeleton, *f_iter); 
+    f_skeleton << indent() << function_signature(*f_iter, "") << " {" << endl << indent() 
+               << "  // Your implementation goes here" << endl << indent() << "  printf(\"" 
+               << (*f_iter)->get_name() << "\\n\");" << endl << indent() << "}" << endl << endl; 
+  } 
+ 
+  indent_down(); 
+  f_skeleton << "};" << endl << endl; 
+ 
+  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 
+      << "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));" 
+      << endl << indent() 
+      << "::apache::thrift::stdcxx::shared_ptr<TTransportFactory> transportFactory(new TBufferedTransportFactory());" << endl 
+      << indent() << "::apache::thrift::stdcxx::shared_ptr<TProtocolFactory> protocolFactory(new TBinaryProtocolFactory());" 
+      << endl << endl << indent() 
+      << "TSimpleServer server(processor, serverTransport, transportFactory, protocolFactory);" 
+      << endl << indent() << "server.serve();" << endl << indent() << "return 0;" << endl; 
+  indent_down(); 
+  f_skeleton << "}" << endl << endl; 
+ 
+  // Close the files 
+  f_skeleton.close(); 
+} 
+ 
+/** 
+ * Deserializes a field of any type. 
+ */ 
+void t_cpp_generator::generate_deserialize_field(ostream& out, 
+                                                 t_field* tfield, 
+                                                 string prefix, 
+                                                 string suffix) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+ 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name(); 
+  } 
+ 
+  string name = prefix + tfield->get_name() + suffix; 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_deserialize_struct(out, (t_struct*)type, name, is_reference(tfield)); 
+  } else if (type->is_container()) { 
+    generate_deserialize_container(out, type, name); 
+  } else if (type->is_base_type()) { 
+    indent(out) << "xfer += iprot->"; 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "compiler error: cannot serialize void field in a struct: " + name; 
+      break; 
+    case t_base_type::TYPE_STRING: 
+      if (type->is_binary()) { 
+        out << "readBinary(" << name << ");"; 
+      } else { 
+        out << "readString(" << name << ");"; 
+      } 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      out << "readBool(" << name << ");"; 
+      break; 
+    case t_base_type::TYPE_I8: 
+      out << "readByte(" << name << ");"; 
+      break; 
+    case t_base_type::TYPE_I16: 
+      out << "readI16(" << name << ");"; 
+      break; 
+    case t_base_type::TYPE_I32: 
+      out << "readI32(" << name << ");"; 
+      break; 
+    case t_base_type::TYPE_I64: 
+      out << "readI64(" << name << ");"; 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      out << "readDouble(" << name << ");"; 
+      break; 
+    default: 
+      throw "compiler error: no C++ reader for base type " + t_base_type::t_base_name(tbase) + name; 
+    } 
+    out << endl; 
+  } else if (type->is_enum()) { 
+    string t = tmp("ecast"); 
+    out << indent() << "int32_t " << t << ";" << endl << indent() << "xfer += iprot->readI32(" << t 
+        << ");" << endl << indent() << name << " = (" << type_name(type) << ")" << t << ";" << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n", 
+           tfield->get_name().c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+/** 
+ * Generates an unserializer for a variable. This makes two key assumptions, 
+ * first that there is a const char* variable named data that points to the 
+ * buffer for deserialization, and that there is a variable protocol which 
+ * is a reference to a TProtocol serialization object. 
+ */ 
+void t_cpp_generator::generate_deserialize_struct(ostream& out, 
+                                                  t_struct* tstruct, 
+                                                  string prefix, 
+                                                  bool pointer) { 
+  if (pointer) { 
+    indent(out) << "if (!" << prefix << ") { " << endl; 
+    indent(out) << "  " << prefix << " = ::apache::thrift::stdcxx::shared_ptr<" << type_name(tstruct) << ">(new " 
+                << type_name(tstruct) << ");" << endl; 
+    indent(out) << "}" << endl; 
+    indent(out) << "xfer += " << prefix << "->read(iprot);" << endl; 
+    indent(out) << "bool wasSet = false;" << endl; 
+    const vector<t_field*>& members = tstruct->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    for (f_iter = members.begin(); f_iter != members.end(); ++f_iter) { 
+ 
+      indent(out) << "if (" << prefix << "->__isset." << (*f_iter)->get_name() 
+                  << ") { wasSet = true; }" << endl; 
+    } 
+    indent(out) << "if (!wasSet) { " << prefix << ".reset(); }" << endl; 
+  } else { 
+    indent(out) << "xfer += " << prefix << ".read(iprot);" << endl; 
+  } 
+} 
+ 
+void t_cpp_generator::generate_deserialize_container(ostream& out, t_type* ttype, string prefix) { 
+  scope_up(out); 
+ 
+  string size = tmp("_size"); 
+  string ktype = tmp("_ktype"); 
+  string vtype = tmp("_vtype"); 
+  string etype = tmp("_etype"); 
+ 
+  t_container* tcontainer = (t_container*)ttype; 
+  bool use_push = tcontainer->has_cpp_name(); 
+ 
+  indent(out) << prefix << ".clear();" << endl << indent() << "uint32_t " << size << ";" << endl; 
+ 
+  // Declare variables, read header 
+  if (ttype->is_map()) { 
+    out << indent() << "::apache::thrift::protocol::TType " << ktype << ";" << endl << indent() 
+        << "::apache::thrift::protocol::TType " << vtype << ";" << endl << indent() 
+        << "xfer += iprot->readMapBegin(" << ktype << ", " << vtype << ", " << size << ");" << endl; 
+  } else if (ttype->is_set()) { 
+    out << indent() << "::apache::thrift::protocol::TType " << etype << ";" << endl << indent() 
+        << "xfer += iprot->readSetBegin(" << etype << ", " << size << ");" << endl; 
+  } else if (ttype->is_list()) { 
+    out << indent() << "::apache::thrift::protocol::TType " << etype << ";" << endl << indent() 
+        << "xfer += iprot->readListBegin(" << etype << ", " << size << ");" << endl; 
+    if (!use_push) { 
+      indent(out) << prefix << ".resize(" << size << ");" << endl; 
+    } 
+  } 
+ 
+  // For loop iterates over elements 
+  string i = tmp("_i"); 
+  out << indent() << "uint32_t " << i << ";" << endl << indent() << "for (" << i << " = 0; " << i 
+      << " < " << size << "; ++" << i << ")" << endl; 
+ 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    generate_deserialize_map_element(out, (t_map*)ttype, prefix); 
+  } else if (ttype->is_set()) { 
+    generate_deserialize_set_element(out, (t_set*)ttype, prefix); 
+  } else if (ttype->is_list()) { 
+    generate_deserialize_list_element(out, (t_list*)ttype, prefix, use_push, i); 
+  } 
+ 
+  scope_down(out); 
+ 
+  // Read container end 
+  if (ttype->is_map()) { 
+    indent(out) << "xfer += iprot->readMapEnd();" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "xfer += iprot->readSetEnd();" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "xfer += iprot->readListEnd();" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+/** 
+ * Generates code to deserialize a map 
+ */ 
+void t_cpp_generator::generate_deserialize_map_element(ostream& out, t_map* tmap, string prefix) { 
+  string key = tmp("_key"); 
+  string val = tmp("_val"); 
+  t_field fkey(tmap->get_key_type(), key); 
+  t_field fval(tmap->get_val_type(), val); 
+ 
+  out << indent() << declare_field(&fkey) << endl; 
+ 
+  generate_deserialize_field(out, &fkey); 
+  indent(out) << declare_field(&fval, false, false, false, true) << " = " << prefix << "[" << key 
+              << "];" << endl; 
+ 
+  generate_deserialize_field(out, &fval); 
+} 
+ 
+void t_cpp_generator::generate_deserialize_set_element(ostream& out, t_set* tset, string prefix) { 
+  string elem = tmp("_elem"); 
+  t_field felem(tset->get_elem_type(), elem); 
+ 
+  indent(out) << declare_field(&felem) << endl; 
+ 
+  generate_deserialize_field(out, &felem); 
+ 
+  indent(out) << prefix << ".insert(" << elem << ");" << endl; 
+} 
+ 
+void t_cpp_generator::generate_deserialize_list_element(ostream& out, 
+                                                        t_list* tlist, 
+                                                        string prefix, 
+                                                        bool use_push, 
+                                                        string index) { 
+  if (use_push) { 
+    string elem = tmp("_elem"); 
+    t_field felem(tlist->get_elem_type(), elem); 
+    indent(out) << declare_field(&felem) << endl; 
+    generate_deserialize_field(out, &felem); 
+    indent(out) << prefix << ".push_back(" << elem << ");" << endl; 
+  } else { 
+    t_field felem(tlist->get_elem_type(), prefix + "[" + index + "]"); 
+    generate_deserialize_field(out, &felem); 
+  } 
+} 
+ 
+/** 
+ * Serializes a field of any type. 
+ * 
+ * @param tfield The field to serialize 
+ * @param prefix Name to prepend to field name 
+ */ 
+void t_cpp_generator::generate_serialize_field(ostream& out, 
+                                               t_field* tfield, 
+                                               string prefix, 
+                                               string suffix) { 
+  t_type* type = get_true_type(tfield->get_type()); 
+ 
+  string name = prefix + tfield->get_name() + suffix; 
+ 
+  // Do nothing for void types 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + name; 
+  } 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_serialize_struct(out, (t_struct*)type, name, is_reference(tfield)); 
+  } else if (type->is_container()) { 
+    generate_serialize_container(out, type, name); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+ 
+    indent(out) << "xfer += oprot->"; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + name; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "writeBinary(" << name << ");"; 
+        } else { 
+          out << "writeString(" << name << ");"; 
+        } 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "writeBool(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "writeByte(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "writeI16(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "writeI32(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "writeI64(" << name << ");"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "writeDouble(" << name << ");"; 
+        break; 
+      default: 
+        throw "compiler error: no C++ writer for base type " + t_base_type::t_base_name(tbase) 
+            + name; 
+      } 
+    } else if (type->is_enum()) { 
+      out << "writeI32((int32_t)" << name << ");"; 
+    } 
+    out << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO SERIALIZE FIELD '%s' TYPE '%s'\n", 
+           name.c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+/** 
+ * Serializes all the members of a struct. 
+ * 
+ * @param tstruct The struct to serialize 
+ * @param prefix  String prefix to attach to all fields 
+ */ 
+void t_cpp_generator::generate_serialize_struct(ostream& out, 
+                                                t_struct* tstruct, 
+                                                string prefix, 
+                                                bool pointer) { 
+  if (pointer) { 
+    indent(out) << "if (" << prefix << ") {" << endl; 
+    indent(out) << "  xfer += " << prefix << "->write(oprot); " << endl; 
+    indent(out) << "} else {" 
+                << "oprot->writeStructBegin(\"" << tstruct->get_name() << "\"); " << endl; 
+    indent(out) << "  oprot->writeStructEnd();" << endl; 
+    indent(out) << "  oprot->writeFieldStop();" << endl; 
+    indent(out) << "}" << endl; 
+  } else { 
+    indent(out) << "xfer += " << prefix << ".write(oprot);" << endl; 
+  } 
+} 
+ 
+void t_cpp_generator::generate_serialize_container(ostream& out, t_type* ttype, string prefix) { 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "xfer += oprot->writeMapBegin(" << type_to_enum(((t_map*)ttype)->get_key_type()) 
+                << ", " << type_to_enum(((t_map*)ttype)->get_val_type()) << ", " 
+                << "static_cast<uint32_t>(" << prefix << ".size()));" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "xfer += oprot->writeSetBegin(" << type_to_enum(((t_set*)ttype)->get_elem_type()) 
+                << ", " 
+                << "static_cast<uint32_t>(" << prefix << ".size()));" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "xfer += oprot->writeListBegin(" 
+                << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", " 
+                << "static_cast<uint32_t>(" << prefix << ".size()));" << endl; 
+  } 
+ 
+  string iter = tmp("_iter"); 
+  out << indent() << type_name(ttype) << "::const_iterator " << iter << ";" << endl << indent() 
+      << "for (" << iter << " = " << prefix << ".begin(); " << iter << " != " << prefix 
+      << ".end(); ++" << iter << ")" << endl; 
+  scope_up(out); 
+  if (ttype->is_map()) { 
+    generate_serialize_map_element(out, (t_map*)ttype, iter); 
+  } else if (ttype->is_set()) { 
+    generate_serialize_set_element(out, (t_set*)ttype, iter); 
+  } else if (ttype->is_list()) { 
+    generate_serialize_list_element(out, (t_list*)ttype, iter); 
+  } 
+  scope_down(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "xfer += oprot->writeMapEnd();" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "xfer += oprot->writeSetEnd();" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "xfer += oprot->writeListEnd();" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+/** 
+ * Serializes the members of a map. 
+ * 
+ */ 
+void t_cpp_generator::generate_serialize_map_element(ostream& out, t_map* tmap, string iter) { 
+  t_field kfield(tmap->get_key_type(), iter + "->first"); 
+  generate_serialize_field(out, &kfield, ""); 
+ 
+  t_field vfield(tmap->get_val_type(), iter + "->second"); 
+  generate_serialize_field(out, &vfield, ""); 
+} 
+ 
+/** 
+ * Serializes the members of a set. 
+ */ 
+void t_cpp_generator::generate_serialize_set_element(ostream& out, t_set* tset, string iter) { 
+  t_field efield(tset->get_elem_type(), "(*" + iter + ")"); 
+  generate_serialize_field(out, &efield, ""); 
+} 
+ 
+/** 
+ * Serializes the members of a list. 
+ */ 
+void t_cpp_generator::generate_serialize_list_element(ostream& out, t_list* tlist, string iter) { 
+  t_field efield(tlist->get_elem_type(), "(*" + iter + ")"); 
+  generate_serialize_field(out, &efield, ""); 
+} 
+ 
+/** 
+ * Makes a :: prefix for a namespace 
+ * 
+ * @param ns The namespace, w/ periods in it 
+ * @return Namespaces 
+ */ 
+string t_cpp_generator::namespace_prefix(string ns) { 
+  // Always start with "::", to avoid possible name collisions with 
+  // other names in one of the current namespaces. 
+  // 
+  // We also need a leading space, in case the name is used inside of a 
+  // template parameter.  "MyTemplate<::foo::Bar>" is not valid C++, 
+  // since "<:" is an alternative token for "[". 
+  string result = " ::"; 
+ 
+  if (ns.size() == 0) { 
+    return result; 
+  } 
+  string::size_type loc; 
+  while ((loc = ns.find(".")) != string::npos) { 
+    result += ns.substr(0, loc); 
+    result += "::"; 
+    ns = ns.substr(loc + 1); 
+  } 
+  if (ns.size() > 0) { 
+    result += ns + "::"; 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Opens namespace. 
+ * 
+ * @param ns The namespace, w/ periods in it 
+ * @return Namespaces 
+ */ 
+string t_cpp_generator::namespace_open(string ns) { 
+  if (ns.size() == 0) { 
+    return ""; 
+  } 
+  string result = ""; 
+  string separator = ""; 
+  string::size_type loc; 
+  while ((loc = ns.find(".")) != string::npos) { 
+    result += separator; 
+    result += "namespace "; 
+    result += ns.substr(0, loc); 
+    result += " {"; 
+    separator = " "; 
+    ns = ns.substr(loc + 1); 
+  } 
+  if (ns.size() > 0) { 
+    result += separator + "namespace " + ns + " {"; 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Closes namespace. 
+ * 
+ * @param ns The namespace, w/ periods in it 
+ * @return Namespaces 
+ */ 
+string t_cpp_generator::namespace_close(string ns) { 
+  if (ns.size() == 0) { 
+    return ""; 
+  } 
+  string result = "}"; 
+  string::size_type loc; 
+  while ((loc = ns.find(".")) != string::npos) { 
+    result += "}"; 
+    ns = ns.substr(loc + 1); 
+  } 
+  result += " // namespace"; 
+  return result; 
+} 
+ 
+/** 
+ * Returns a C++ type name 
+ * 
+ * @param ttype The type 
+ * @return String of the type name, i.e. std::set<type> 
+ */ 
+string t_cpp_generator::type_name(t_type* ttype, bool in_typedef, bool arg) { 
+  if (ttype->is_base_type()) { 
+    string bname = base_type_name(((t_base_type*)ttype)->get_base()); 
+    std::map<string, string>::iterator it = ttype->annotations_.find("cpp.type"); 
+    if (it != ttype->annotations_.end()) { 
+      bname = it->second; 
+    } 
+ 
+    if (!arg) { 
+      return bname; 
+    } 
+ 
+    if (((t_base_type*)ttype)->get_base() == t_base_type::TYPE_STRING) { 
+      return "const " + bname + "&"; 
+    } else { 
+      return "const " + bname; 
+    } 
+  } 
+ 
+  // Check for a custom overloaded C++ name 
+  if (ttype->is_container()) { 
+    string cname; 
+ 
+    t_container* tcontainer = (t_container*)ttype; 
+    if (tcontainer->has_cpp_name()) { 
+      cname = tcontainer->get_cpp_name(); 
+    } else if (ttype->is_map()) { 
+      t_map* tmap = (t_map*)ttype; 
+      cname = "std::map<" + type_name(tmap->get_key_type(), in_typedef) + ", " 
+              + type_name(tmap->get_val_type(), in_typedef) + "> "; 
+    } else if (ttype->is_set()) { 
+      t_set* tset = (t_set*)ttype; 
+      cname = "std::set<" + type_name(tset->get_elem_type(), in_typedef) + "> "; 
+    } else if (ttype->is_list()) { 
+      t_list* tlist = (t_list*)ttype; 
+      cname = "std::vector<" + type_name(tlist->get_elem_type(), in_typedef) + "> "; 
+    } 
+ 
+    if (arg) { 
+      return "const " + cname + "&"; 
+    } else { 
+      return cname; 
+    } 
+  } 
+ 
+  string class_prefix; 
+  if (in_typedef && (ttype->is_struct() || ttype->is_xception())) { 
+    class_prefix = "class "; 
+  } 
+ 
+  // Check if it needs to be namespaced 
+  string pname; 
+  t_program* program = ttype->get_program(); 
+  if (program != NULL && program != program_) { 
+    pname = class_prefix + namespace_prefix(program->get_namespace("cpp")) + ttype->get_name(); 
+  } else { 
+    pname = class_prefix + ttype->get_name(); 
+  } 
+ 
+  if (ttype->is_enum() && !gen_pure_enums_) { 
+    pname += "::type"; 
+  } 
+ 
+  if (arg) { 
+    if (is_complex_type(ttype)) { 
+      return "const " + pname + "&"; 
+    } else { 
+      return "const " + pname; 
+    } 
+  } else { 
+    return pname; 
+  } 
+} 
+ 
+/** 
+ * Returns the C++ type that corresponds to the thrift type. 
+ * 
+ * @param tbase The base type 
+ * @return Explicit C++ type, i.e. "int32_t" 
+ */ 
+string t_cpp_generator::base_type_name(t_base_type::t_base tbase) { 
+  switch (tbase) { 
+  case t_base_type::TYPE_VOID: 
+    return "void"; 
+  case t_base_type::TYPE_STRING: 
+    return "std::string"; 
+  case t_base_type::TYPE_BOOL: 
+    return "bool"; 
+  case t_base_type::TYPE_I8: 
+    return "int8_t"; 
+  case t_base_type::TYPE_I16: 
+    return "int16_t"; 
+  case t_base_type::TYPE_I32: 
+    return "int32_t"; 
+  case t_base_type::TYPE_I64: 
+    return "int64_t"; 
+  case t_base_type::TYPE_DOUBLE: 
+    return "double"; 
+  default: 
+    throw "compiler error: no C++ base type name for base type " + t_base_type::t_base_name(tbase); 
+  } 
+} 
+ 
+/** 
+ * Declares a field, which may include initialization as necessary. 
+ * 
+ * @param ttype The type 
+ * @return Field declaration, i.e. int x = 0; 
+ */ 
+string t_cpp_generator::declare_field(t_field* tfield, 
+                                      bool init, 
+                                      bool pointer, 
+                                      bool constant, 
+                                      bool reference) { 
+  // TODO(mcslee): do we ever need to initialize the field? 
+  string result = ""; 
+  if (constant) { 
+    result += "const "; 
+  } 
+  result += type_name(tfield->get_type()); 
+  if (is_reference(tfield)) { 
+    result = "::apache::thrift::stdcxx::shared_ptr<" + result + ">"; 
+  } 
+  if (pointer) { 
+    result += "*"; 
+  } 
+  if (reference) { 
+    result += "&"; 
+  } 
+  result += " " + tfield->get_name(); 
+  if (init) { 
+    t_type* type = get_true_type(tfield->get_type()); 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+      case t_base_type::TYPE_STRING: 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        result += " = false"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+      case t_base_type::TYPE_I16: 
+      case t_base_type::TYPE_I32: 
+      case t_base_type::TYPE_I64: 
+        result += " = 0"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        result += " = (double)0"; 
+        break; 
+      default: 
+        throw "compiler error: no C++ initializer for base type " + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      result += " = (" + type_name(type) + ")0"; 
+    } 
+  } 
+  if (!reference) { 
+    result += ";"; 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Renders a function signature of the form 'type name(args)' 
+ * 
+ * @param tfunction Function definition 
+ * @return String of rendered function definition 
+ */ 
+string t_cpp_generator::function_signature(t_function* tfunction, 
+                                           string style, 
+                                           string prefix, 
+                                           bool name_params) { 
+  t_type* ttype = tfunction->get_returntype(); 
+  t_struct* arglist = tfunction->get_arglist(); 
+  bool has_xceptions = !tfunction->get_xceptions()->get_members().empty(); 
+ 
+  if (style == "") { 
+    if (is_complex_type(ttype)) { 
+      return "void " + prefix + tfunction->get_name() + "(" + type_name(ttype) 
+             + (name_params ? "& _return" : "& /* _return */") 
+             + argument_list(arglist, name_params, true) + ")"; 
+    } else { 
+      return type_name(ttype) + " " + prefix + tfunction->get_name() + "(" 
+             + argument_list(arglist, name_params) + ")"; 
+    } 
+  } else if (style.substr(0, 3) == "Cob") { 
+    string cob_type; 
+    string exn_cob; 
+    if (style == "CobCl") { 
+      cob_type = "(" + service_name_ + "CobClient"; 
+      if (gen_templates_) { 
+        cob_type += "T<Protocol_>"; 
+      } 
+      cob_type += "* client)"; 
+    } else if (style == "CobSv") { 
+      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 */"; 
+      } 
+    } else { 
+      throw "UNKNOWN STYLE"; 
+    } 
+ 
+    return "void " + prefix + tfunction->get_name() + "(::apache::thrift::stdcxx::function<void" + cob_type + "> cob" 
+           + exn_cob + argument_list(arglist, name_params, true) + ")"; 
+  } else { 
+    throw "UNKNOWN STYLE"; 
+  } 
+} 
+ 
+/** 
+ * Renders a field list 
+ * 
+ * @param tstruct The struct definition 
+ * @return Comma sepearated list of all field names in that struct 
+ */ 
+string t_cpp_generator::argument_list(t_struct* tstruct, bool name_params, bool start_comma) { 
+  string result = ""; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = !start_comma; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      result += ", "; 
+    } 
+    result += type_name((*f_iter)->get_type(), false, true) + " " 
+              + (name_params ? (*f_iter)->get_name() : "/* " + (*f_iter)->get_name() + " */"); 
+  } 
+  return result; 
+} 
+ 
+/** 
+ * Converts the parse type to a C++ enum string for the given type. 
+ * 
+ * @param type Thrift Type 
+ * @return String of C++ code to definition of that type constant 
+ */ 
+string t_cpp_generator::type_to_enum(t_type* type) { 
+  type = get_true_type(type); 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "NO T_VOID CONSTRUCT"; 
+    case t_base_type::TYPE_STRING: 
+      return "::apache::thrift::protocol::T_STRING"; 
+    case t_base_type::TYPE_BOOL: 
+      return "::apache::thrift::protocol::T_BOOL"; 
+    case t_base_type::TYPE_I8: 
+      return "::apache::thrift::protocol::T_BYTE"; 
+    case t_base_type::TYPE_I16: 
+      return "::apache::thrift::protocol::T_I16"; 
+    case t_base_type::TYPE_I32: 
+      return "::apache::thrift::protocol::T_I32"; 
+    case t_base_type::TYPE_I64: 
+      return "::apache::thrift::protocol::T_I64"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "::apache::thrift::protocol::T_DOUBLE"; 
+    } 
+  } else if (type->is_enum()) { 
+    return "::apache::thrift::protocol::T_I32"; 
+  } else if (type->is_struct()) { 
+    return "::apache::thrift::protocol::T_STRUCT"; 
+  } else if (type->is_xception()) { 
+    return "::apache::thrift::protocol::T_STRUCT"; 
+  } else if (type->is_map()) { 
+    return "::apache::thrift::protocol::T_MAP"; 
+  } else if (type->is_set()) { 
+    return "::apache::thrift::protocol::T_SET"; 
+  } else if (type->is_list()) { 
+    return "::apache::thrift::protocol::T_LIST"; 
+  } 
+ 
+  throw "INVALID TYPE IN type_to_enum: " + type->get_name(); 
+} 
+ 
+string t_cpp_generator::get_include_prefix(const t_program& program) const { 
+  string include_prefix = program.get_include_prefix(); 
+  if (!use_include_prefix_ || (include_prefix.size() > 0 && include_prefix[0] == '/')) { 
+    // if flag is turned off or this is absolute path, return empty prefix 
+    return ""; 
+  } 
+ 
+  string::size_type last_slash = string::npos; 
+  if ((last_slash = include_prefix.rfind("/")) != string::npos) { 
+    return include_prefix.substr(0, last_slash) 
+           + (get_program()->is_out_path_absolute() ? "/" : "/" + out_dir_base_ + "/"); 
+  } 
+ 
+  return ""; 
+} 
+ 
+THRIFT_REGISTER_GENERATOR( 
+    cpp, 
+    "C++", 
+    "    cob_style:       Generate \"Continuation OBject\"-style classes.\n" 
+    "    no_client_completion:\n" 
+    "                     Omit calls to completion__() in CobClient class.\n" 
+    "    no_default_operators:\n" 
+    "                     Omits generation of default operators ==, != and <\n" 
+    "    templates:       Generate templatized reader/writer methods.\n" 
+    "    pure_enums:      Generate pure enums instead of wrapper classes.\n" 
+    "    include_prefix:  Use full include paths in generated files.\n" 
+    "    moveable_types:  Generate move constructors and assignment operators.\n" 
+    "    no_ostream_operators:\n" 
+    "                     Omit generation of ostream definitions.\n" 
+    "    no_skeleton:     Omits generation of skeleton.\n") 

contrib/restricted/thrift/compiler/thrift/generate/t_csharp_generator.cc

@@ -1,3224 +1,3224 @@
-/*
- * 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.
- *
- * Contains some contributions under the Thrift Software License.
- * Please see doc/old-thrift-license.txt in the Thrift distribution for
- * details.
- */
-
-#include <cassert>
-
-#include <string>
-#include <fstream>
-#include <iostream>
-#include <vector>
-#include <cctype>
-
-#include <stdlib.h>
-#include <sys/stat.h>
-#include <sstream>
-
-#include "thrift/platform.h"
-#include "thrift/generate/t_oop_generator.h"
-
-using std::map;
-using std::ostream;
-using std::ostringstream;
-using std::string;
-using std::stringstream;
-using std::vector;
-
-static const string endl = "\n"; // avoid ostream << std::endl flushes
-
-struct member_mapping_scope {
-  void* scope_member;
-  std::map<std::string, std::string> mapping_table;
-};
-
-class t_csharp_generator : public t_oop_generator {
-public:
-  t_csharp_generator(t_program* program,
-                     const std::map<std::string, std::string>& parsed_options,
-                     const std::string& option_string)
-    : t_oop_generator(program) {
-    (void)option_string;
-
-    std::map<std::string, std::string>::const_iterator iter;
-
-    async_ = false;
-    nullable_ = false;
-    hashcode_ = false;
-    union_ = false;
-    serialize_ = false;
-    wcf_ = false;
-    wcf_namespace_.clear();
-    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) {
-      if( iter->first.compare("async") == 0) {
-        async_ = true;
-      } else if( iter->first.compare("nullable") == 0) {
-        nullable_ = true;
-      } else if( iter->first.compare("hashcode") == 0) {
-        hashcode_ = true;
-      } else if( iter->first.compare("union") == 0) {
-        union_ = true;
-      } else if( iter->first.compare("serial") == 0) {
-        serialize_ = true;
-        wcf_namespace_ = iter->second; // since there can be only one namespace
-      } else if( iter->first.compare("wcf") == 0) {
-        wcf_ = true;
-        wcf_namespace_ = iter->second;
-      } else {
-        throw "unknown option csharp:" + iter->first;
-      }
-    }
-
-    out_dir_base_ = "gen-csharp";
-  }
-  void init_generator();
-  void close_generator();
-
-  void generate_consts(std::vector<t_const*> consts);
-
-  void generate_typedef(t_typedef* ttypedef);
-  void generate_enum(t_enum* tenum);
-  void generate_struct(t_struct* tstruct);
-  void generate_union(t_struct* tunion);
-  void generate_xception(t_struct* txception);
-  void generate_service(t_service* tservice);
-  void generate_property(ostream& out, t_field* tfield, bool isPublic, bool generateIsset);
-  void generate_csharp_property(ostream& out,
-                                t_field* tfield,
-                                bool isPublic,
-                                bool includeIsset = true,
-                                std::string fieldPrefix = "");
-  bool print_const_value(std::ostream& out,
-                         std::string name,
-                         t_type* type,
-                         t_const_value* value,
-                         bool in_static,
-                         bool defval = false,
-                         bool needtype = false);
-  std::string render_const_value(std::ostream& out,
-                                 std::string name,
-                                 t_type* type,
-                                 t_const_value* value);
-  void print_const_constructor(std::ostream& out, std::vector<t_const*> consts);
-  void print_const_def_value(std::ostream& out,
-                             std::string name,
-                             t_type* type,
-                             t_const_value* value);
-
-  void generate_csharp_struct(t_struct* tstruct, bool is_exception);
-  void generate_csharp_union(t_struct* tunion);
-  void generate_csharp_struct_definition(std::ostream& out,
-                                         t_struct* tstruct,
-                                         bool is_xception = false,
-                                         bool in_class = false,
-                                         bool is_result = false);
-  void generate_csharp_union_definition(std::ostream& out, t_struct* tunion);
-  void generate_csharp_union_class(std::ostream& out, t_struct* tunion, t_field* tfield);
-  void generate_csharp_wcffault(std::ostream& out, t_struct* tstruct);
-  void generate_csharp_struct_reader(std::ostream& out, t_struct* tstruct);
-  void generate_csharp_struct_result_writer(std::ostream& out, t_struct* tstruct);
-  void generate_csharp_struct_writer(std::ostream& out, t_struct* tstruct);
-  void generate_csharp_struct_tostring(std::ostream& out, t_struct* tstruct);
-  void generate_csharp_struct_equals(std::ostream& out, t_struct* tstruct);
-  void generate_csharp_struct_hashcode(std::ostream& out, t_struct* tstruct);
-  void generate_csharp_union_reader(std::ostream& out, t_struct* tunion);
-
-  void generate_function_helpers(t_function* tfunction);
-  void generate_service_interface(t_service* tservice);
-  void generate_separate_service_interfaces(t_service* tservice);
-  void generate_sync_service_interface(t_service* tservice);
-  void generate_async_service_interface(t_service* tservice);
-  void generate_combined_service_interface(t_service* tservice);
-  void generate_silverlight_async_methods(t_service* tservice);
-  void generate_service_helpers(t_service* tservice);
-  void generate_service_client(t_service* tservice);
-  void generate_service_server(t_service* tservice);
-  void generate_service_server_sync(t_service* tservice);
-  void generate_service_server_async(t_service* tservice);
-  void generate_process_function(t_service* tservice, t_function* function);
-  void generate_process_function_async(t_service* tservice, t_function* function);
-
-  void generate_deserialize_field(std::ostream& out,
-                                  t_field* tfield,
-                                  std::string prefix = "",
-                                  bool is_propertyless = false);
-  void generate_deserialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = "");
-  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = "");
-  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = "");
-  void generate_deserialize_list_element(std::ostream& out, t_list* list, std::string prefix = "");
-  void generate_serialize_field(std::ostream& out,
-                                t_field* tfield,
-                                std::string prefix = "",
-                                bool is_element = false,
-                                bool is_propertyless = false);
-  void generate_serialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = "");
-  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = "");
-  void generate_serialize_map_element(std::ostream& out,
-                                      t_map* tmap,
-                                      std::string iter,
-                                      std::string map);
-  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter);
-  void generate_serialize_list_element(std::ostream& out, t_list* tlist, std::string iter);
-
-  void generate_csharp_doc(std::ostream& out, t_field* field);
-  void generate_csharp_doc(std::ostream& out, t_doc* tdoc);
-  void generate_csharp_doc(std::ostream& out, t_function* tdoc);
-  void generate_csharp_docstring_comment(std::ostream& out, string contents);
-
-  void start_csharp_namespace(std::ostream& out);
-  void end_csharp_namespace(std::ostream& out);
-
-  std::string csharp_type_usings();
-  std::string csharp_thrift_usings();
-
-  std::string type_name(t_type* ttype,
-                        bool in_countainer = false,
-                        bool in_init = false,
-                        bool in_param = false,
-                        bool is_required = false);
-  std::string base_type_name(t_base_type* tbase,
-                             bool in_container = false,
-                             bool in_param = false,
-                             bool is_required = false);
-  std::string declare_field(t_field* tfield, bool init = false, std::string prefix = "");
-  std::string function_signature_async_begin(t_function* tfunction, std::string prefix = "");
-  std::string function_signature_async_end(t_function* tfunction, std::string prefix = "");
-  std::string function_signature_async(t_function* tfunction, std::string prefix = "");
-  std::string function_signature(t_function* tfunction, std::string prefix = "");
-  std::string argument_list(t_struct* tstruct);
-  std::string type_to_enum(t_type* ttype);
-  std::string prop_name(t_field* tfield, bool suppress_mapping = false);
-  std::string get_enum_class_name(t_type* type);
-
-  bool field_has_default(t_field* tfield) { return tfield->get_value() != NULL; }
-
-  bool field_is_required(t_field* tfield) { return tfield->get_req() == t_field::T_REQUIRED; }
-
-  bool type_can_be_null(t_type* ttype) {
-    while (ttype->is_typedef()) {
-      ttype = ((t_typedef*)ttype)->get_type();
-    }
-
-    return ttype->is_container() || ttype->is_struct() || ttype->is_xception()
-           || ttype->is_string();
-  }
-
-private:
-  std::string namespace_name_;
-  ofstream_with_content_based_conditional_update f_service_;
-  std::string namespace_dir_;
-  bool async_;
-  bool nullable_;
-  bool union_;
-  bool hashcode_;
-  bool serialize_;
-  bool wcf_;
-  std::string wcf_namespace_;
-
-  std::map<std::string, int> csharp_keywords;
-  std::vector<member_mapping_scope>  member_mapping_scopes;
-
-  void init_keywords();
-  std::string normalize_name(std::string name);
-  std::string make_valid_csharp_identifier(std::string const& fromName);
-  void prepare_member_name_mapping(t_struct* tstruct);
-  void prepare_member_name_mapping(void* scope,
-                                   const vector<t_field*>& members,
-                                   const string& structname);
-  void cleanup_member_name_mapping(void* scope);
-  string get_mapped_member_name(string oldname);
-};
-
-void t_csharp_generator::init_generator() {
-  MKDIR(get_out_dir().c_str());
-  namespace_name_ = program_->get_namespace("csharp");
-
-  string dir = namespace_name_;
-  string subdir = get_out_dir().c_str();
-  string::size_type loc;
-
-  while ((loc = dir.find(".")) != string::npos) {
-    subdir = subdir + "/" + dir.substr(0, loc);
-    MKDIR(subdir.c_str());
-    dir = dir.substr(loc + 1);
-  }
-  if (dir.size() > 0) {
-    subdir = subdir + "/" + dir;
-    MKDIR(subdir.c_str());
-  }
-
-  namespace_dir_ = subdir;
-  init_keywords();
-
-  while( ! member_mapping_scopes.empty()) {
-    cleanup_member_name_mapping( member_mapping_scopes.back().scope_member);
-  }
-
-  pverbose("C# options:\n");
-  pverbose("- async ...... %s\n", (async_ ? "ON" : "off"));
-  pverbose("- nullable ... %s\n", (nullable_ ? "ON" : "off"));
-  pverbose("- union ...... %s\n", (union_ ? "ON" : "off"));
-  pverbose("- hashcode ... %s\n", (hashcode_ ? "ON" : "off"));
-  pverbose("- serialize .. %s\n", (serialize_ ? "ON" : "off"));
-  pverbose("- wcf ........ %s\n", (wcf_ ? "ON" : "off"));
-}
-
-std::string t_csharp_generator::normalize_name(std::string name) {
-  string tmp(name);
-  std::transform(tmp.begin(), tmp.end(), tmp.begin(), static_cast<int (*)(int)>(std::tolower));
-
-  // un-conflict keywords by prefixing with "@"
-  if (csharp_keywords.find(tmp) != csharp_keywords.end()) {
-    return "@" + name;
-  }
-
-  // no changes necessary
-  return name;
-}
-
-void t_csharp_generator::init_keywords() {
-  csharp_keywords.clear();
-
-  // C# keywords
-  csharp_keywords["abstract"] = 1;
-  csharp_keywords["as"] = 1;
-  csharp_keywords["base"] = 1;
-  csharp_keywords["bool"] = 1;
-  csharp_keywords["break"] = 1;
-  csharp_keywords["byte"] = 1;
-  csharp_keywords["case"] = 1;
-  csharp_keywords["catch"] = 1;
-  csharp_keywords["char"] = 1;
-  csharp_keywords["checked"] = 1;
-  csharp_keywords["class"] = 1;
-  csharp_keywords["const"] = 1;
-  csharp_keywords["continue"] = 1;
-  csharp_keywords["decimal"] = 1;
-  csharp_keywords["default"] = 1;
-  csharp_keywords["delegate"] = 1;
-  csharp_keywords["do"] = 1;
-  csharp_keywords["double"] = 1;
-  csharp_keywords["else"] = 1;
-  csharp_keywords["enum"] = 1;
-  csharp_keywords["event"] = 1;
-  csharp_keywords["explicit"] = 1;
-  csharp_keywords["extern"] = 1;
-  csharp_keywords["false"] = 1;
-  csharp_keywords["finally"] = 1;
-  csharp_keywords["fixed"] = 1;
-  csharp_keywords["float"] = 1;
-  csharp_keywords["for"] = 1;
-  csharp_keywords["foreach"] = 1;
-  csharp_keywords["goto"] = 1;
-  csharp_keywords["if"] = 1;
-  csharp_keywords["implicit"] = 1;
-  csharp_keywords["in"] = 1;
-  csharp_keywords["int"] = 1;
-  csharp_keywords["interface"] = 1;
-  csharp_keywords["internal"] = 1;
-  csharp_keywords["is"] = 1;
-  csharp_keywords["lock"] = 1;
-  csharp_keywords["long"] = 1;
-  csharp_keywords["namespace"] = 1;
-  csharp_keywords["new"] = 1;
-  csharp_keywords["null"] = 1;
-  csharp_keywords["object"] = 1;
-  csharp_keywords["operator"] = 1;
-  csharp_keywords["out"] = 1;
-  csharp_keywords["override"] = 1;
-  csharp_keywords["params"] = 1;
-  csharp_keywords["private"] = 1;
-  csharp_keywords["protected"] = 1;
-  csharp_keywords["public"] = 1;
-  csharp_keywords["readonly"] = 1;
-  csharp_keywords["ref"] = 1;
-  csharp_keywords["return"] = 1;
-  csharp_keywords["sbyte"] = 1;
-  csharp_keywords["sealed"] = 1;
-  csharp_keywords["short"] = 1;
-  csharp_keywords["sizeof"] = 1;
-  csharp_keywords["stackalloc"] = 1;
-  csharp_keywords["static"] = 1;
-  csharp_keywords["string"] = 1;
-  csharp_keywords["struct"] = 1;
-  csharp_keywords["switch"] = 1;
-  csharp_keywords["this"] = 1;
-  csharp_keywords["throw"] = 1;
-  csharp_keywords["true"] = 1;
-  csharp_keywords["try"] = 1;
-  csharp_keywords["typeof"] = 1;
-  csharp_keywords["uint"] = 1;
-  csharp_keywords["ulong"] = 1;
-  csharp_keywords["unchecked"] = 1;
-  csharp_keywords["unsafe"] = 1;
-  csharp_keywords["ushort"] = 1;
-  csharp_keywords["using"] = 1;
-  csharp_keywords["virtual"] = 1;
-  csharp_keywords["void"] = 1;
-  csharp_keywords["volatile"] = 1;
-  csharp_keywords["while"] = 1;
-
-  // C# contextual keywords
-  csharp_keywords["add"] = 1;
-  csharp_keywords["alias"] = 1;
-  csharp_keywords["ascending"] = 1;
-  csharp_keywords["async"] = 1;
-  csharp_keywords["await"] = 1;
-  csharp_keywords["descending"] = 1;
-  csharp_keywords["dynamic"] = 1;
-  csharp_keywords["from"] = 1;
-  csharp_keywords["get"] = 1;
-  csharp_keywords["global"] = 1;
-  csharp_keywords["group"] = 1;
-  csharp_keywords["into"] = 1;
-  csharp_keywords["join"] = 1;
-  csharp_keywords["let"] = 1;
-  csharp_keywords["orderby"] = 1;
-  csharp_keywords["partial"] = 1;
-  csharp_keywords["remove"] = 1;
-  csharp_keywords["select"] = 1;
-  csharp_keywords["set"] = 1;
-  csharp_keywords["value"] = 1;
-  csharp_keywords["var"] = 1;
-  csharp_keywords["where"] = 1;
-  csharp_keywords["yield"] = 1;
-}
-
-void t_csharp_generator::start_csharp_namespace(ostream& out) {
-  if (!namespace_name_.empty()) {
-    out << "namespace " << namespace_name_ << "\n";
-    scope_up(out);
-  }
-}
-
-void t_csharp_generator::end_csharp_namespace(ostream& out) {
-  if (!namespace_name_.empty()) {
-    scope_down(out);
-  }
-}
-
-string t_csharp_generator::csharp_type_usings() {
-  return string() + "using System;\n" + "using System.Collections;\n"
-         + "using System.Collections.Generic;\n" + "using System.Text;\n" + "using System.IO;\n"
-         + ((async_) ? "using System.Threading.Tasks;\n" : "") + "using Thrift;\n"
-         + "using Thrift.Collections;\n" + ((serialize_ || wcf_) ? "#if !SILVERLIGHT\n" : "")
-         + ((serialize_ || wcf_) ? "using System.Xml.Serialization;\n" : "")
-         + ((serialize_ || wcf_) ? "#endif\n" : "") + (wcf_ ? "//using System.ServiceModel;\n" : "")
-         + "using System.Runtime.Serialization;\n";
-}
-
-string t_csharp_generator::csharp_thrift_usings() {
-  return string() + "using Thrift.Protocol;\n" + "using Thrift.Transport;\n";
-}
-
-void t_csharp_generator::close_generator() {
-}
-void t_csharp_generator::generate_typedef(t_typedef* ttypedef) {
-  (void)ttypedef;
-}
-
-void t_csharp_generator::generate_enum(t_enum* tenum) {
-  string f_enum_name = namespace_dir_ + "/" + (tenum->get_name()) + ".cs";
-  ofstream_with_content_based_conditional_update f_enum;
-  f_enum.open(f_enum_name.c_str());
-
-  f_enum << autogen_comment() << endl;
-
-  start_csharp_namespace(f_enum);
-
-  generate_csharp_doc(f_enum, tenum);
-
-  indent(f_enum) << "public enum " << tenum->get_name() << "\n";
-  scope_up(f_enum);
-
-  vector<t_enum_value*> constants = tenum->get_constants();
-  vector<t_enum_value*>::iterator c_iter;
-  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) {
-    generate_csharp_doc(f_enum, *c_iter);
-
-    int value = (*c_iter)->get_value();
-    indent(f_enum) << (*c_iter)->get_name() << " = " << value << "," << endl;
-  }
-
-  scope_down(f_enum);
-
-  end_csharp_namespace(f_enum);
-
-  f_enum.close();
-}
-
-void t_csharp_generator::generate_consts(std::vector<t_const*> consts) {
-  if (consts.empty()) {
-    return;
-  }
-  string f_consts_name = namespace_dir_ + '/' + program_name_ + ".Constants.cs";
-  ofstream_with_content_based_conditional_update f_consts;
-  f_consts.open(f_consts_name.c_str());
-
-  f_consts << autogen_comment() << csharp_type_usings() << endl;
-
-  start_csharp_namespace(f_consts);
-
-  indent(f_consts) << "public static class " << make_valid_csharp_identifier(program_name_)
-                   << "Constants" << endl;
-  scope_up(f_consts);
-
-  vector<t_const*>::iterator c_iter;
-  bool need_static_constructor = false;
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    generate_csharp_doc(f_consts, (*c_iter));
-    if (print_const_value(f_consts,
-                          (*c_iter)->get_name(),
-                          (*c_iter)->get_type(),
-                          (*c_iter)->get_value(),
-                          false)) {
-      need_static_constructor = true;
-    }
-  }
-
-  if (need_static_constructor) {
-    print_const_constructor(f_consts, consts);
-  }
-
-  scope_down(f_consts);
-  end_csharp_namespace(f_consts);
-  f_consts.close();
-}
-
-void t_csharp_generator::print_const_def_value(std::ostream& out,
-                                               string name,
-                                               t_type* type,
-                                               t_const_value* value) {
-  if (type->is_struct() || type->is_xception()) {
-    const vector<t_field*>& fields = ((t_struct*)type)->get_members();
-    vector<t_field*>::const_iterator f_iter;
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    prepare_member_name_mapping((t_struct*)type);
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      t_field* field = NULL;
-      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-        if ((*f_iter)->get_name() == v_iter->first->get_string()) {
-          field = (*f_iter);
-        }
-      }
-      if (field == NULL) {
-        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string();
-      }
-      t_type* field_type = field->get_type();
-      string val = render_const_value(out, name, field_type, v_iter->second);
-      indent(out) << name << "." << prop_name(field) << " = " << val << ";" << endl;
-    }
-    cleanup_member_name_mapping((t_struct*)type);
-  } else if (type->is_map()) {
-    t_type* ktype = ((t_map*)type)->get_key_type();
-    t_type* vtype = ((t_map*)type)->get_val_type();
-    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map();
-    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string key = render_const_value(out, name, ktype, v_iter->first);
-      string val = render_const_value(out, name, vtype, v_iter->second);
-      indent(out) << name << "[" << key << "]"
-                  << " = " << val << ";" << endl;
-    }
-  } else if (type->is_list() || type->is_set()) {
-    t_type* etype;
-    if (type->is_list()) {
-      etype = ((t_list*)type)->get_elem_type();
-    } else {
-      etype = ((t_set*)type)->get_elem_type();
-    }
-
-    const vector<t_const_value*>& val = value->get_list();
-    vector<t_const_value*>::const_iterator v_iter;
-    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) {
-      string val = render_const_value(out, name, etype, *v_iter);
-      indent(out) << name << ".Add(" << val << ");" << endl;
-    }
-  }
-}
-
-void t_csharp_generator::print_const_constructor(std::ostream& out, std::vector<t_const*> consts) {
-  indent(out) << "static " << make_valid_csharp_identifier(program_name_).c_str() << "Constants()"
-              << endl;
-  scope_up(out);
-  vector<t_const*>::iterator c_iter;
-  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) {
-    string name = (*c_iter)->get_name();
-    t_type* type = (*c_iter)->get_type();
-    t_const_value* value = (*c_iter)->get_value();
-
-    print_const_def_value(out, name, type, value);
-  }
-  scope_down(out);
-}
-
-// it seems like all that methods that call this are using in_static to be the opposite of what it
-// would imply
-bool t_csharp_generator::print_const_value(std::ostream& out,
-                                           string name,
-                                           t_type* type,
-                                           t_const_value* value,
-                                           bool in_static,
-                                           bool defval,
-                                           bool needtype) {
-  indent(out);
-  bool need_static_construction = !in_static;
-  while (type->is_typedef()) {
-    type = ((t_typedef*)type)->get_type();
-  }
-
-  if (!defval || needtype) {
-    out << (in_static ? "" : type->is_base_type() ? "public const " : "public static ")
-        << type_name(type) << " ";
-  }
-  if (type->is_base_type()) {
-    string v2 = render_const_value(out, name, type, value);
-    out << name << " = " << v2 << ";" << endl;
-    need_static_construction = false;
-  } else if (type->is_enum()) {
-    out << name << " = " << type_name(type, false, true) << "." << value->get_identifier_name()
-        << ";" << endl;
-    need_static_construction = false;
-  } else if (type->is_struct() || type->is_xception()) {
-    out << name << " = new " << type_name(type) << "();" << endl;
-  } else if (type->is_map()) {
-    out << name << " = new " << type_name(type, true, true) << "();" << endl;
-  } else if (type->is_list() || type->is_set()) {
-    out << name << " = new " << type_name(type) << "();" << endl;
-  }
-
-  if (defval && !type->is_base_type() && !type->is_enum()) {
-    print_const_def_value(out, name, type, value);
-  }
-
-  return need_static_construction;
-}
-
-std::string t_csharp_generator::render_const_value(ostream& out,
-                                                   string name,
-                                                   t_type* type,
-                                                   t_const_value* value) {
-  (void)name;
-  std::ostringstream render;
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_STRING:
-      render << '"' << get_escaped_string(value) << '"';
-      break;
-    case t_base_type::TYPE_BOOL:
-      render << ((value->get_integer() > 0) ? "true" : "false");
-      break;
-    case t_base_type::TYPE_I8:
-    case t_base_type::TYPE_I16:
-    case t_base_type::TYPE_I32:
-    case t_base_type::TYPE_I64:
-      render << value->get_integer();
-      break;
-    case t_base_type::TYPE_DOUBLE:
-      if (value->get_type() == t_const_value::CV_INTEGER) {
-        render << value->get_integer();
-      } else {
-        render << value->get_double();
-      }
-      break;
-    default:
-      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase);
-    }
-  } else if (type->is_enum()) {
-    render << type->get_name() << "." << value->get_identifier_name();
-  } else {
-    string t = tmp("tmp");
-    print_const_value(out, t, type, value, true, true, true);
-    render << t;
-  }
-
-  return render.str();
-}
-
-void t_csharp_generator::generate_struct(t_struct* tstruct) {
-  if (union_ && tstruct->is_union()) {
-    generate_csharp_union(tstruct);
-  } else {
-    generate_csharp_struct(tstruct, false);
-  }
-}
-
-void t_csharp_generator::generate_xception(t_struct* txception) {
-  generate_csharp_struct(txception, true);
-}
-
-void t_csharp_generator::generate_csharp_struct(t_struct* tstruct, bool is_exception) {
-  string f_struct_name = namespace_dir_ + "/" + (tstruct->get_name()) + ".cs";
-  ofstream_with_content_based_conditional_update f_struct;
-
-  f_struct.open(f_struct_name.c_str());
-
-  f_struct << autogen_comment() << csharp_type_usings() << csharp_thrift_usings() << endl;
-
-  generate_csharp_struct_definition(f_struct, tstruct, is_exception);
-
-  f_struct.close();
-}
-
-void t_csharp_generator::generate_csharp_struct_definition(ostream& out,
-                                                           t_struct* tstruct,
-                                                           bool is_exception,
-                                                           bool in_class,
-                                                           bool is_result) {
-
-  if (!in_class) {
-    start_csharp_namespace(out);
-  }
-
-  out << endl;
-
-  generate_csharp_doc(out, tstruct);
-  prepare_member_name_mapping(tstruct);
-
-  indent(out) << "#if !SILVERLIGHT" << endl;
-  indent(out) << "[Serializable]" << endl;
-  indent(out) << "#endif" << endl;
-  if ((serialize_ || wcf_) && !is_exception) {
-    indent(out) << "[DataContract(Namespace=\"" << wcf_namespace_ << "\")]"
-                << endl; // do not make exception classes directly WCF serializable, we provide a
-                         // separate "fault" for that
-  }
-  bool is_final = (tstruct->annotations_.find("final") != tstruct->annotations_.end());
-
-  indent(out) << "public " << (is_final ? "sealed " : "") << "partial class "
-              << normalize_name(tstruct->get_name()) << " : ";
-
-  if (is_exception) {
-    out << "TException, ";
-  }
-  out << "TBase";
-
-  out << endl;
-
-  scope_up(out);
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  // make private members with public Properties
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    // if the field is requied, then we use auto-properties
-    if (!field_is_required((*m_iter)) && (!nullable_ || field_has_default((*m_iter)))) {
-      indent(out) << "private " << declare_field(*m_iter, false, "_") << endl;
-    }
-  }
-  out << endl;
-
-  bool has_non_required_fields = false;
-  bool has_non_required_default_value_fields = false;
-  bool has_required_fields = false;
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    generate_csharp_doc(out, *m_iter);
-    generate_property(out, *m_iter, true, true);
-    bool is_required = field_is_required((*m_iter));
-    bool has_default = field_has_default((*m_iter));
-    if (is_required) {
-      has_required_fields = true;
-    } else {
-      if (has_default) {
-        has_non_required_default_value_fields = true;
-      }
-      has_non_required_fields = true;
-    }
-  }
-
-  bool generate_isset = (nullable_ && has_non_required_default_value_fields)
-                        || (!nullable_ && has_non_required_fields);
-  if (generate_isset) {
-    out << endl;
-    if (serialize_ || wcf_) {
-      out << indent() << "[XmlIgnore] // XmlSerializer" << endl << indent()
-          << "[DataMember(Order = 1)]  // XmlObjectSerializer, DataContractJsonSerializer, etc."
-          << endl;
-    }
-    out << indent() << "public Isset __isset;" << endl << indent() << "#if !SILVERLIGHT" << endl
-        << indent() << "[Serializable]" << endl << indent() << "#endif" << endl;
-    if (serialize_ || wcf_) {
-      indent(out) << "[DataContract]" << endl;
-    }
-    indent(out) << "public struct Isset {" << endl;
-    indent_up();
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      bool is_required = field_is_required((*m_iter));
-      bool has_default = field_has_default((*m_iter));
-      // if it is required, don't need Isset for that variable
-      // if it is not required, if it has a default value, we need to generate Isset
-      // if we are not nullable, then we generate Isset
-      if (!is_required && (!nullable_ || has_default)) {
-        if (serialize_ || wcf_) {
-          indent(out) << "[DataMember]" << endl;
-        }
-        indent(out) << "public bool " << normalize_name((*m_iter)->get_name()) << ";" << endl;
-      }
-    }
-
-    indent_down();
-    indent(out) << "}" << endl << endl;
-
-    if (generate_isset && (serialize_ || wcf_)) {
-      indent(out) << "#region XmlSerializer support" << endl << endl;
-
-      for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-        bool is_required = field_is_required((*m_iter));
-        bool has_default = field_has_default((*m_iter));
-        // if it is required, don't need Isset for that variable
-        // if it is not required, if it has a default value, we need to generate Isset
-        // if we are not nullable, then we generate Isset
-        if (!is_required && (!nullable_ || has_default)) {
-          indent(out) << "public bool ShouldSerialize" << prop_name((*m_iter)) << "()" << endl;
-          indent(out) << "{" << endl;
-          indent_up();
-          indent(out) << "return __isset." << normalize_name((*m_iter)->get_name()) << ";" << endl;
-          indent_down();
-          indent(out) << "}" << endl << endl;
-        }
-      }
-
-      indent(out) << "#endregion XmlSerializer support" << endl << endl;
-    }
-  }
-
-  // We always want a default, no argument constructor for Reading
-  indent(out) << "public " << normalize_name(tstruct->get_name()) << "() {" << endl;
-  indent_up();
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    t_type* t = (*m_iter)->get_type();
-    while (t->is_typedef()) {
-      t = ((t_typedef*)t)->get_type();
-    }
-    if ((*m_iter)->get_value() != NULL) {
-      if (field_is_required((*m_iter))) {
-        print_const_value(out, "this." + prop_name(*m_iter), t, (*m_iter)->get_value(), true, true);
-      } else {
-        print_const_value(out,
-                          "this._" + (*m_iter)->get_name(),
-                          t,
-                          (*m_iter)->get_value(),
-                          true,
-                          true);
-        // Optionals with defaults are marked set
-        indent(out) << "this.__isset." << normalize_name((*m_iter)->get_name()) << " = true;"
-                    << endl;
-      }
-    }
-  }
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  if (has_required_fields) {
-    indent(out) << "public " << tstruct->get_name() << "(";
-    bool first = true;
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      if (field_is_required((*m_iter))) {
-        if (first) {
-          first = false;
-        } else {
-          out << ", ";
-        }
-        out << type_name((*m_iter)->get_type()) << " " << normalize_name((*m_iter)->get_name());
-      }
-    }
-    out << ") : this() {" << endl;
-    indent_up();
-
-    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-      if (field_is_required((*m_iter))) {
-        indent(out) << "this." << prop_name((*m_iter)) << " = " << normalize_name((*m_iter)->get_name()) << ";"
-                    << endl;
-      }
-    }
-
-    indent_down();
-    indent(out) << "}" << endl << endl;
-  }
-
-  generate_csharp_struct_reader(out, tstruct);
-  if (is_result) {
-    generate_csharp_struct_result_writer(out, tstruct);
-  } else {
-    generate_csharp_struct_writer(out, tstruct);
-  }
-  if (hashcode_) {
-    generate_csharp_struct_equals(out, tstruct);
-    generate_csharp_struct_hashcode(out, tstruct);
-  }
-  generate_csharp_struct_tostring(out, tstruct);
-  scope_down(out);
-  out << endl;
-
-  // generate a corresponding WCF fault to wrap the exception
-  if ((serialize_ || wcf_) && is_exception) {
-    generate_csharp_wcffault(out, tstruct);
-  }
-
-  cleanup_member_name_mapping(tstruct);
-  if (!in_class) {
-    end_csharp_namespace(out);
-  }
-}
-
-void t_csharp_generator::generate_csharp_wcffault(ostream& out, t_struct* tstruct) {
-  out << endl;
-  indent(out) << "#if !SILVERLIGHT" << endl;
-  indent(out) << "[Serializable]" << endl;
-  indent(out) << "#endif" << endl;
-  indent(out) << "[DataContract]" << endl;
-  bool is_final = (tstruct->annotations_.find("final") != tstruct->annotations_.end());
-
-  indent(out) << "public " << (is_final ? "sealed " : "") << "partial class " << tstruct->get_name()
-              << "Fault" << endl;
-
-  scope_up(out);
-
-  const vector<t_field*>& members = tstruct->get_members();
-  vector<t_field*>::const_iterator m_iter;
-
-  // make private members with public Properties
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    indent(out) << "private " << declare_field(*m_iter, false, "_") << endl;
-  }
-  out << endl;
-
-  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) {
-    generate_property(out, *m_iter, true, false);
-  }
-
-  scope_down(out);
-  out << endl;
-}
-
-void t_csharp_generator::generate_csharp_struct_reader(ostream& out, t_struct* tstruct) {
-  indent(out) << "public void Read (TProtocol iprot)" << endl;
-  scope_up(out);
-
-  out << indent() << "iprot.IncrementRecursionDepth();" << endl;
-  out << indent() << "try" << endl;
-  scope_up(out);
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  // Required variables aren't in __isset, so we need tmp vars to check them
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (field_is_required((*f_iter))) {
-      indent(out) << "bool isset_" << (*f_iter)->get_name() << " = false;" << endl;
-    }
-  }
-
-  indent(out) << "TField field;" << endl << indent() << "iprot.ReadStructBegin();" << endl;
-
-  indent(out) << "while (true)" << endl;
-  scope_up(out);
-
-  indent(out) << "field = iprot.ReadFieldBegin();" << endl;
-
-  indent(out) << "if (field.Type == TType.Stop) { " << endl;
-  indent_up();
-  indent(out) << "break;" << endl;
-  indent_down();
-  indent(out) << "}" << endl;
-
-  indent(out) << "switch (field.ID)" << endl;
-
-  scope_up(out);
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    bool is_required = field_is_required((*f_iter));
-    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl;
-    indent_up();
-    indent(out) << "if (field.Type == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl;
-    indent_up();
-
-    generate_deserialize_field(out, *f_iter);
-    if (is_required) {
-      indent(out) << "isset_" << (*f_iter)->get_name() << " = true;" << endl;
-    }
-
-    indent_down();
-    out << indent() << "} else { " << endl << indent() << "  TProtocolUtil.Skip(iprot, field.Type);"
-        << endl << indent() << "}" << endl << indent() << "break;" << endl;
-    indent_down();
-  }
-
-  indent(out) << "default: " << endl;
-  indent_up();
-  indent(out) << "TProtocolUtil.Skip(iprot, field.Type);" << endl;
-  indent(out) << "break;" << endl;
-  indent_down();
-
-  scope_down(out);
-
-  indent(out) << "iprot.ReadFieldEnd();" << endl;
-
-  scope_down(out);
-
-  indent(out) << "iprot.ReadStructEnd();" << endl;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (field_is_required((*f_iter))) {
-      indent(out) << "if (!isset_" << (*f_iter)->get_name() << ")" << endl;
-      indent_up();
-      out << indent()
-          << "throw new TProtocolException(TProtocolException.INVALID_DATA, "
-          << "\"required field " << prop_name((*f_iter)) << " not set\");"
-          << endl;
-      indent_down();
-    }
-  }
-
-  scope_down(out);
-  out << indent() << "finally" << endl;
-  scope_up(out);
-  out << indent() << "iprot.DecrementRecursionDepth();" << endl;
-  scope_down(out);
-
-  indent_down();
-
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_csharp_struct_writer(ostream& out, t_struct* tstruct) {
-  out << indent() << "public void Write(TProtocol oprot) {" << endl;
-  indent_up();
-
-  out << indent() << "oprot.IncrementRecursionDepth();" << endl;
-  out << indent() << "try" << endl;
-  scope_up(out);
-
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_sorted_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  indent(out) << "TStruct struc = new TStruct(\"" << name << "\");" << endl;
-  indent(out) << "oprot.WriteStructBegin(struc);" << endl;
-
-  if (fields.size() > 0) {
-    indent(out) << "TField field = new TField();" << endl;
-    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-      bool is_required = field_is_required((*f_iter));
-      bool has_default = field_has_default((*f_iter));
-      bool null_allowed = type_can_be_null((*f_iter)->get_type());
-
-      if (is_required)
-      {
-        if (null_allowed) {
-          indent(out) << "if (" << prop_name((*f_iter)) << " == null)" << endl;
-          indent_up();
-          out << indent()
-              << "throw new TProtocolException(TProtocolException.INVALID_DATA, "
-              << "\"required field " << prop_name((*f_iter)) << " not set\");"
-              << endl;
-          indent_down();
-        }
-      }
-      else
-      {
-        if (nullable_ && !has_default) {
-            indent(out) << "if (" << prop_name((*f_iter)) << " != null) {" << endl;
-        }
-        else if (null_allowed) {
-          out << indent()
-              << "if (" << prop_name((*f_iter)) << " != null && __isset."
-              << normalize_name((*f_iter)->get_name()) << ") {"
-              << endl;
-        }
-        else {
-           indent(out) << "if (__isset." << normalize_name((*f_iter)->get_name()) << ") {" << endl;
-        }
-        indent_up();
-      }
-      indent(out) << "field.Name = \"" << (*f_iter)->get_name() << "\";" << endl;
-      indent(out) << "field.Type = " << type_to_enum((*f_iter)->get_type()) << ";" << endl;
-      indent(out) << "field.ID = " << (*f_iter)->get_key() << ";" << endl;
-      indent(out) << "oprot.WriteFieldBegin(field);" << endl;
-
-      generate_serialize_field(out, *f_iter);
-
-      indent(out) << "oprot.WriteFieldEnd();" << endl;
-      if (!is_required) {
-        indent_down();
-        indent(out) << "}" << endl;
-      }
-    }
-  }
-
-  indent(out) << "oprot.WriteFieldStop();" << endl;
-  indent(out) << "oprot.WriteStructEnd();" << endl;
-
-  scope_down(out);
-  out << indent() << "finally" << endl;
-  scope_up(out);
-  out << indent() << "oprot.DecrementRecursionDepth();" << endl;
-  scope_down(out);
-
-  indent_down();
-
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_csharp_struct_result_writer(ostream& out, t_struct* tstruct) {
-  indent(out) << "public void Write(TProtocol oprot) {" << endl;
-  indent_up();
-
-  out << indent() << "oprot.IncrementRecursionDepth();" << endl;
-  out << indent() << "try" << endl;
-  scope_up(out);
-
-  string name = tstruct->get_name();
-  const vector<t_field*>& fields = tstruct->get_sorted_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  indent(out) << "TStruct struc = new TStruct(\"" << name << "\");" << endl;
-  indent(out) << "oprot.WriteStructBegin(struc);" << endl;
-
-  if (fields.size() > 0) {
-    indent(out) << "TField field = new TField();" << endl;
-    bool first = true;
-    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-      if (first) {
-        first = false;
-        out << endl << indent() << "if ";
-      } else {
-        out << " else if ";
-      }
-
-      if (nullable_) {
-        out << "(this." << prop_name((*f_iter)) << " != null) {" << endl;
-      } else {
-        out << "(this.__isset." << normalize_name((*f_iter)->get_name()) << ") {" << endl;
-      }
-      indent_up();
-
-      bool null_allowed = !nullable_ && type_can_be_null((*f_iter)->get_type());
-      if (null_allowed) {
-        indent(out) << "if (" << prop_name(*f_iter) << " != null) {" << endl;
-        indent_up();
-      }
-
-      indent(out) << "field.Name = \"" << prop_name(*f_iter) << "\";" << endl;
-      indent(out) << "field.Type = " << type_to_enum((*f_iter)->get_type()) << ";" << endl;
-      indent(out) << "field.ID = " << (*f_iter)->get_key() << ";" << endl;
-      indent(out) << "oprot.WriteFieldBegin(field);" << endl;
-
-      generate_serialize_field(out, *f_iter);
-
-      indent(out) << "oprot.WriteFieldEnd();" << endl;
-
-      if (null_allowed) {
-        indent_down();
-        indent(out) << "}" << endl;
-      }
-
-      indent_down();
-      indent(out) << "}";
-    }
-  }
-
-  out << endl << indent() << "oprot.WriteFieldStop();" << endl << indent()
-      << "oprot.WriteStructEnd();" << endl;
-
-  scope_down(out);
-  out << indent() << "finally" << endl;
-  scope_up(out);
-  out << indent() << "oprot.DecrementRecursionDepth();" << endl;
-  scope_down(out);
-
-  indent_down();
-
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_csharp_struct_tostring(ostream& out, t_struct* tstruct) {
-  indent(out) << "public override string ToString() {" << endl;
-  indent_up();
-
-  indent(out) << "StringBuilder __sb = new StringBuilder(\"" << tstruct->get_name() << "(\");"
-              << endl;
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  bool useFirstFlag = false;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (!field_is_required((*f_iter))) {
-      indent(out) << "bool __first = true;" << endl;
-      useFirstFlag = true;
-    }
-    break;
-  }
-
-  bool had_required = false; // set to true after first required field has been processed
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    bool is_required = field_is_required((*f_iter));
-    bool has_default = field_has_default((*f_iter));
-    if (nullable_ && !has_default && !is_required) {
-      indent(out) << "if (" << prop_name((*f_iter)) << " != null) {" << endl;
-      indent_up();
-    } else if (!is_required) {
-      bool null_allowed = type_can_be_null((*f_iter)->get_type());
-      if (null_allowed) {
-        indent(out) << "if (" << prop_name((*f_iter)) << " != null && __isset."
-                    << normalize_name((*f_iter)->get_name()) << ") {" << endl;
-        indent_up();
-      } else {
-        indent(out) << "if (__isset." << normalize_name((*f_iter)->get_name()) << ") {" << endl;
-        indent_up();
-      }
-    }
-
-    if (useFirstFlag && (!had_required)) {
-      indent(out) << "if(!__first) { __sb.Append(\", \"); }" << endl;
-      if (!is_required) {
-        indent(out) << "__first = false;" << endl;
-      }
-      indent(out) << "__sb.Append(\"" << prop_name((*f_iter)) << ": \");" << endl;
-    } else {
-      indent(out) << "__sb.Append(\", " << prop_name((*f_iter)) << ": \");" << endl;
-    }
-
-    t_type* ttype = (*f_iter)->get_type();
-    if (ttype->is_xception() || ttype->is_struct()) {
-      indent(out) << "__sb.Append(" << prop_name((*f_iter))
-                  << "== null ? \"<null>\" : " << prop_name((*f_iter)) << ".ToString());" << endl;
-    } else {
-      indent(out) << "__sb.Append(" << prop_name((*f_iter)) << ");" << endl;
-    }
-
-    if (!is_required) {
-      indent_down();
-      indent(out) << "}" << endl;
-    } else {
-      had_required = true; // now __first must be false, so we don't need to check it anymore
-    }
-  }
-
-  indent(out) << "__sb.Append(\")\");" << endl;
-  indent(out) << "return __sb.ToString();" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_csharp_union(t_struct* tunion) {
-  string f_union_name = namespace_dir_ + "/" + (tunion->get_name()) + ".cs";
-  ofstream_with_content_based_conditional_update f_union;
-
-  f_union.open(f_union_name.c_str());
-
-  f_union << autogen_comment() << csharp_type_usings() << csharp_thrift_usings() << endl;
-
-  generate_csharp_union_definition(f_union, tunion);
-
-  f_union.close();
-}
-
-void t_csharp_generator::generate_csharp_union_definition(std::ostream& out, t_struct* tunion) {
-  // Let's define the class first
-  start_csharp_namespace(out);
-
-  indent(out) << "public abstract partial class " << tunion->get_name() << " : TAbstractBase {"
-              << endl;
-
-  indent_up();
-
-  indent(out) << "public abstract void Write(TProtocol protocol);" << endl;
-  indent(out) << "public readonly bool Isset;" << endl;
-  indent(out) << "public abstract object Data { get; }" << endl;
-
-  indent(out) << "protected " << tunion->get_name() << "(bool isset) {" << endl;
-  indent_up();
-  indent(out) << "Isset = isset;" << endl;
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  indent(out) << "public class ___undefined : " << tunion->get_name() << " {" << endl;
-  indent_up();
-
-  indent(out) << "public override object Data { get { return null; } }" << endl;
-
-  indent(out) << "public ___undefined() : base(false) {}" << endl << endl;
-
-  indent(out) << "public override void Write(TProtocol protocol) {" << endl;
-  indent_up();
-  indent(out) << "throw new TProtocolException( TProtocolException.INVALID_DATA, \"Cannot persist "
-                 "an union type which is not set.\");" << endl;
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  const vector<t_field*>& fields = tunion->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    generate_csharp_union_class(out, tunion, (*f_iter));
-  }
-
-  generate_csharp_union_reader(out, tunion);
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-
-  end_csharp_namespace(out);
-}
-
-void t_csharp_generator::generate_csharp_union_class(std::ostream& out,
-                                                     t_struct* tunion,
-                                                     t_field* tfield) {
-  indent(out) << "public class " << tfield->get_name() << " : " << tunion->get_name() << " {"
-              << endl;
-  indent_up();
-  indent(out) << "private " << type_name(tfield->get_type()) << " _data;" << endl;
-  indent(out) << "public override object Data { get { return _data; } }" << endl;
-  indent(out) << "public " << tfield->get_name() << "(" << type_name(tfield->get_type())
-              << " data) : base(true) {" << endl;
-  indent_up();
-  indent(out) << "this._data = data;" << endl;
-  indent_down();
-  indent(out) << "}" << endl;
-  indent(out) << "public override void Write(TProtocol oprot) {" << endl;
-  indent_up();
-
-  out << indent() << "oprot.IncrementRecursionDepth();" << endl;
-  out << indent() << "try" << endl;
-  scope_up(out);
-
-  indent(out) << "TStruct struc = new TStruct(\"" << tunion->get_name() << "\");" << endl;
-  indent(out) << "oprot.WriteStructBegin(struc);" << endl;
-
-  indent(out) << "TField field = new TField();" << endl;
-  indent(out) << "field.Name = \"" << tfield->get_name() << "\";" << endl;
-  indent(out) << "field.Type = " << type_to_enum(tfield->get_type()) << ";" << endl;
-  indent(out) << "field.ID = " << tfield->get_key() << ";" << endl;
-  indent(out) << "oprot.WriteFieldBegin(field);" << endl;
-
-  generate_serialize_field(out, tfield, "_data", true, true);
-
-  indent(out) << "oprot.WriteFieldEnd();" << endl;
-  indent(out) << "oprot.WriteFieldStop();" << endl;
-  indent(out) << "oprot.WriteStructEnd();" << endl;
-  indent_down();
-
-  scope_down(out);
-  out << indent() << "finally" << endl;
-  scope_up(out);
-  out << indent() << "oprot.DecrementRecursionDepth();" << endl;
-  scope_down(out);
-
-  indent(out) << "}" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_csharp_struct_equals(ostream& out, t_struct* tstruct) {
-  indent(out) << "public override bool Equals(object that) {" << endl;
-  indent_up();
-
-  indent(out) << "var other = that as " << type_name(tstruct) << ";" << endl;
-  indent(out) << "if (other == null) return false;" << endl;
-  indent(out) << "if (ReferenceEquals(this, other)) return true;" << endl;
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  bool first = true;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-      indent(out) << "return ";
-      indent_up();
-    } else {
-      out << endl;
-      indent(out) << "&& ";
-    }
-    if (!field_is_required((*f_iter)) && !(nullable_ && !field_has_default((*f_iter)))) {
-      out << "((__isset." << normalize_name((*f_iter)->get_name()) << " == other.__isset."
-          << normalize_name((*f_iter)->get_name()) << ") && ((!__isset."
-          << normalize_name((*f_iter)->get_name()) << ") || (";
-    }
-    t_type* ttype = (*f_iter)->get_type();
-    if (ttype->is_container() || ttype->is_binary()) {
-      out << "TCollections.Equals(";
-    } else {
-      out << "System.Object.Equals(";
-    }
-    out << prop_name((*f_iter)) << ", other." << prop_name((*f_iter)) << ")";
-    if (!field_is_required((*f_iter)) && !(nullable_ && !field_has_default((*f_iter)))) {
-      out << ")))";
-    }
-  }
-  if (first) {
-    indent(out) << "return true;" << endl;
-  } else {
-    out << ";" << endl;
-    indent_down();
-  }
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_csharp_struct_hashcode(ostream& out, t_struct* tstruct) {
-  indent(out) << "public override int GetHashCode() {" << endl;
-  indent_up();
-
-  indent(out) << "int hashcode = 0;" << endl;
-  indent(out) << "unchecked {" << endl;
-  indent_up();
-
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    t_type* ttype = (*f_iter)->get_type();
-    indent(out) << "hashcode = (hashcode * 397) ^ ";
-    if (field_is_required((*f_iter))) {
-      out << "(";
-    } else if (nullable_) {
-      out << "(" << prop_name((*f_iter)) << " == null ? 0 : ";
-    } else {
-      out << "(!__isset." << normalize_name((*f_iter)->get_name()) << " ? 0 : ";
-    }
-    if (ttype->is_container()) {
-      out << "(TCollections.GetHashCode(" << prop_name((*f_iter)) << "))";
-    } else {
-      out << "(" << prop_name((*f_iter)) << ".GetHashCode())";
-    }
-    out << ");" << endl;
-  }
-
-  indent_down();
-  indent(out) << "}" << endl;
-  indent(out) << "return hashcode;" << endl;
-
-  indent_down();
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_service(t_service* tservice) {
-  string f_service_name = namespace_dir_ + "/" + service_name_ + ".cs";
-  f_service_.open(f_service_name.c_str());
-
-  f_service_ << autogen_comment() << csharp_type_usings() << csharp_thrift_usings() << endl;
-
-  start_csharp_namespace(f_service_);
-
-  indent(f_service_) << "public partial class " << normalize_name(service_name_) << " {" << endl;
-  indent_up();
-
-  generate_service_interface(tservice);
-  generate_service_client(tservice);
-  generate_service_server(tservice);
-  generate_service_helpers(tservice);
-
-  indent_down();
-
-  indent(f_service_) << "}" << endl;
-  end_csharp_namespace(f_service_);
-  f_service_.close();
-}
-
-void t_csharp_generator::generate_service_interface(t_service* tservice) {
-  generate_separate_service_interfaces(tservice);
-}
-
-void t_csharp_generator::generate_separate_service_interfaces(t_service* tservice) {
-  generate_sync_service_interface(tservice);
-
-  if (async_) {
-    generate_async_service_interface(tservice);
-  }
-
-  generate_combined_service_interface(tservice);
-}
-
-void t_csharp_generator::generate_sync_service_interface(t_service* tservice) {
-  string extends = "";
-  string extends_iface = "";
-  if (tservice->get_extends() != NULL) {
-    extends = type_name(tservice->get_extends());
-    extends_iface = " : " + extends + ".ISync";
-  }
-
-  generate_csharp_doc(f_service_, tservice);
-
-  if (wcf_) {
-    indent(f_service_) << "[ServiceContract(Namespace=\"" << wcf_namespace_ << "\")]" << endl;
-  }
-  indent(f_service_) << "public interface ISync" << extends_iface << " {" << endl;
-
-  indent_up();
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_csharp_doc(f_service_, *f_iter);
-
-    // if we're using WCF, add the corresponding attributes
-    if (wcf_) {
-      indent(f_service_) << "[OperationContract]" << endl;
-
-      const std::vector<t_field*>& xceptions = (*f_iter)->get_xceptions()->get_members();
-      vector<t_field*>::const_iterator x_iter;
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-        indent(f_service_) << "[FaultContract(typeof("
-          + type_name((*x_iter)->get_type(), false, false) + "Fault))]" << endl;
-      }
-    }
-
-    indent(f_service_) << function_signature(*f_iter) << ";" << endl;
-  }
-  indent_down();
-  f_service_ << indent() << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_async_service_interface(t_service* tservice) {
-  string extends = "";
-  string extends_iface = "";
-  if (tservice->get_extends() != NULL) {
-    extends = type_name(tservice->get_extends());
-    extends_iface = " : " + extends + ".IAsync";
-  }
-
-  generate_csharp_doc(f_service_, tservice);
-
-  if (wcf_) {
-    indent(f_service_) << "[ServiceContract(Namespace=\"" << wcf_namespace_ << "\")]" << endl;
-  }
-  indent(f_service_) << "public interface IAsync" << extends_iface << " {" << endl;
-
-  indent_up();
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_csharp_doc(f_service_, *f_iter);
-
-    // if we're using WCF, add the corresponding attributes
-    if (wcf_) {
-      indent(f_service_) << "[OperationContract]" << endl;
-
-      const std::vector<t_field*>& xceptions = (*f_iter)->get_xceptions()->get_members();
-      vector<t_field*>::const_iterator x_iter;
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-        indent(f_service_) << "[FaultContract(typeof("
-          + type_name((*x_iter)->get_type(), false, false) + "Fault))]" << endl;
-      }
-    }
-
-    indent(f_service_) << function_signature_async(*f_iter) << ";" << endl;
-  }
-  indent_down();
-  f_service_ << indent() << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_combined_service_interface(t_service* tservice) {
-  string extends_iface = " : ISync";
-
-  if (async_) {
-    extends_iface += ", IAsync";
-  }
-
-  generate_csharp_doc(f_service_, tservice);
-
-  if (wcf_) {
-    indent(f_service_) << "[ServiceContract(Namespace=\"" << wcf_namespace_ << "\")]" << endl;
-  }
-
-  indent(f_service_) << "public interface Iface" << extends_iface << " {" << endl;
-
-  indent_up();
-
-  // We need to generate extra old style async methods for silverlight. Since
-  // this isn't something you'd want to implement server-side, just put them into
-  // the main Iface interface.
-  generate_silverlight_async_methods(tservice);
-
-  indent_down();
-
-  f_service_ << indent() << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_silverlight_async_methods(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_csharp_doc(f_service_, *f_iter);
-
-    // For backwards compatibility, include the Begin_, End_ methods if we're generating
-    // with the async flag. I'm not sure this is necessary, so someone with more knowledge
-    // can maybe remove these checks if they know it's safe.
-    if (!async_) {
-      indent(f_service_) << "#if SILVERLIGHT" << endl;
-    }
-
-    indent(f_service_) << function_signature_async_begin(*f_iter, "Begin_") << ";" << endl;
-    indent(f_service_) << function_signature_async_end(*f_iter, "End_") << ";" << endl;
-
-    if (!async_) {
-      indent(f_service_) << "#endif" << endl;
-    }
-  }
-}
-
-void t_csharp_generator::generate_service_helpers(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    t_struct* ts = (*f_iter)->get_arglist();
-    generate_csharp_struct_definition(f_service_, ts, false, true);
-    generate_function_helpers(*f_iter);
-  }
-}
-
-void t_csharp_generator::generate_service_client(t_service* tservice) {
-  string extends = "";
-  string extends_client = "";
-  if (tservice->get_extends() != NULL) {
-    extends = type_name(tservice->get_extends());
-    extends_client = extends + ".Client, ";
-  } else {
-    extends_client = "IDisposable, ";
-  }
-
-  generate_csharp_doc(f_service_, tservice);
-
-  indent(f_service_) << "public class Client : " << extends_client << "Iface {" << endl;
-  indent_up();
-  indent(f_service_) << "public Client(TProtocol prot) : this(prot, prot)" << endl;
-  scope_up(f_service_);
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  indent(f_service_) << "public Client(TProtocol iprot, TProtocol oprot)";
-  if (!extends.empty()) {
-    f_service_ << " : base(iprot, oprot)";
-  }
-  f_service_ << endl;
-
-  scope_up(f_service_);
-  if (extends.empty()) {
-    f_service_ << indent() << "iprot_ = iprot;" << endl << indent() << "oprot_ = oprot;" << endl;
-  }
-  scope_down(f_service_);
-
-  f_service_ << endl;
-
-  if (extends.empty()) {
-    f_service_ << indent() << "protected TProtocol iprot_;" << endl << indent()
-               << "protected TProtocol oprot_;" << endl << indent() << "protected int seqid_;"
-               << endl << endl;
-
-    f_service_ << indent() << "public TProtocol InputProtocol" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "get { return iprot_; }" << endl;
-    scope_down(f_service_);
-
-    f_service_ << indent() << "public TProtocol OutputProtocol" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "get { return oprot_; }" << endl;
-    scope_down(f_service_);
-    f_service_ << endl << endl;
-
-    indent(f_service_) << "#region \" IDisposable Support \"" << endl;
-    indent(f_service_) << "private bool _IsDisposed;" << endl << endl;
-    indent(f_service_) << "// IDisposable" << endl;
-    indent(f_service_) << "public void Dispose()" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "Dispose(true);" << endl;
-    scope_down(f_service_);
-    indent(f_service_) << endl << endl;
-    indent(f_service_) << "protected virtual void Dispose(bool disposing)" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "if (!_IsDisposed)" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "if (disposing)" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "if (iprot_ != null)" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "((IDisposable)iprot_).Dispose();" << endl;
-    scope_down(f_service_);
-    indent(f_service_) << "if (oprot_ != null)" << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "((IDisposable)oprot_).Dispose();" << endl;
-    scope_down(f_service_);
-    scope_down(f_service_);
-    scope_down(f_service_);
-    indent(f_service_) << "_IsDisposed = true;" << endl;
-    scope_down(f_service_);
-    indent(f_service_) << "#endregion" << endl;
-    f_service_ << endl << endl;
-  }
-
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::const_iterator f_iter;
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    string funname = (*f_iter)->get_name();
-
-    indent(f_service_) << endl;
-
-    if (!async_) {
-      indent(f_service_) << "#if SILVERLIGHT" << endl;
-    }
-    // Begin_
-    indent(f_service_) << "public " << function_signature_async_begin(*f_iter, "Begin_") << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "return "
-                       << "send_" << funname << "(callback, state";
-
-    t_struct* arg_struct = (*f_iter)->get_arglist();
-    prepare_member_name_mapping(arg_struct);
-
-    const vector<t_field*>& fields = arg_struct->get_members();
-    vector<t_field*>::const_iterator fld_iter;
-    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-      f_service_ << ", ";
-      f_service_ << normalize_name((*fld_iter)->get_name());
-    }
-    f_service_ << ");" << endl;
-    scope_down(f_service_);
-    f_service_ << endl;
-
-    // End
-    indent(f_service_) << "public " << function_signature_async_end(*f_iter, "End_") << endl;
-    scope_up(f_service_);
-    indent(f_service_) << "oprot_.Transport.EndFlush(asyncResult);" << endl;
-    if (!(*f_iter)->is_oneway()) {
-      f_service_ << indent();
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        f_service_ << "return ";
-      }
-      f_service_ << "recv_" << funname << "();" << endl;
-    }
-    scope_down(f_service_);
-    f_service_ << endl;
-
-    // async
-    bool first;
-    if (async_) {
-      indent(f_service_) << "public async " << function_signature_async(*f_iter, "") << endl;
-      scope_up(f_service_);
-
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        indent(f_service_) << type_name((*f_iter)->get_returntype()) << " retval;" << endl;
-        indent(f_service_) << "retval = ";
-      } else {
-        indent(f_service_);
-      }
-      f_service_ << "await Task.Run(() =>" << endl;
-      scope_up(f_service_);
-      indent(f_service_);
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        f_service_ << "return ";
-      }
-      f_service_ << funname << "(";
-      first = true;
-      for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-        if (first) {
-          first = false;
-        } else {
-          f_service_ << ", ";
-        }
-        f_service_ << (*fld_iter)->get_name();
-      }
-      f_service_ << ");" << endl;
-      indent_down();
-      indent(f_service_) << "});" << endl;
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        indent(f_service_) << "return retval;" << endl;
-      }
-      scope_down(f_service_);
-      f_service_ << endl;
-    }
-
-    if (!async_) {
-      indent(f_service_) << "#endif" << endl << endl;
-    }
-
-    // "Normal" Synchronous invoke
-    generate_csharp_doc(f_service_, *f_iter);
-    indent(f_service_) << "public " << function_signature(*f_iter) << endl;
-    scope_up(f_service_);
-
-    if (!async_) {
-      indent(f_service_) << "#if !SILVERLIGHT" << endl;
-      indent(f_service_) << "send_" << funname << "(";
-
-      first = true;
-      for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-        if (first) {
-          first = false;
-        } else {
-          f_service_ << ", ";
-        }
-        f_service_ << normalize_name((*fld_iter)->get_name());
-      }
-      f_service_ << ");" << endl;
-
-      if (!(*f_iter)->is_oneway()) {
-        f_service_ << indent();
-        if (!(*f_iter)->get_returntype()->is_void()) {
-          f_service_ << "return ";
-        }
-        f_service_ << "recv_" << funname << "();" << endl;
-      }
-      f_service_ << endl;
-
-      indent(f_service_) << "#else" << endl;
-    }
-
-    // Silverlight synchronous invoke
-    indent(f_service_) << "var asyncResult = Begin_" << funname << "(null, null";
-    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-      f_service_ << ", " << normalize_name((*fld_iter)->get_name());
-    }
-    f_service_ << ");" << endl;
-
-    if (!(*f_iter)->is_oneway()) {
-      f_service_ << indent();
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        f_service_ << "return ";
-      }
-      f_service_ << "End_" << funname << "(asyncResult);" << endl;
-    }
-    f_service_ << endl;
-
-    if (!async_) {
-      indent(f_service_) << "#endif" << endl;
-    }
-    scope_down(f_service_);
-
-    // Send
-    t_function send_function(g_type_void,
-                             string("send_") + (*f_iter)->get_name(),
-                             (*f_iter)->get_arglist());
-
-    string argsname = (*f_iter)->get_name() + "_args";
-
-    if (!async_) {
-      indent(f_service_) << "#if SILVERLIGHT" << endl;
-    }
-    indent(f_service_) << "public " << function_signature_async_begin(&send_function) << endl;
-    if (!async_) {
-      indent(f_service_) << "#else" << endl;
-      indent(f_service_) << "public " << function_signature(&send_function) << endl;
-      indent(f_service_) << "#endif" << endl;
-    }
-    scope_up(f_service_);
-
-    f_service_ << indent() << "oprot_.WriteMessageBegin(new TMessage(\"" << funname << "\", "
-               << ((*f_iter)->is_oneway() ? "TMessageType.Oneway" : "TMessageType.Call")
-               << ", seqid_));" << endl << indent() << argsname << " args = new " << argsname
-               << "();" << endl;
-
-    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) {
-      f_service_ << indent() << "args." << prop_name(*fld_iter) << " = "
-                 << normalize_name((*fld_iter)->get_name()) << ";" << endl;
-    }
-
-    f_service_ << indent() << "args.Write(oprot_);" << endl << indent()
-               << "oprot_.WriteMessageEnd();" << endl;
-    ;
-
-    if (!async_) {
-      indent(f_service_) << "#if SILVERLIGHT" << endl;
-    }
-    indent(f_service_) << "return oprot_.Transport.BeginFlush(callback, state);" << endl;
-    if (!async_) {
-      indent(f_service_) << "#else" << endl;
-      indent(f_service_) << "oprot_.Transport.Flush();" << endl;
-      indent(f_service_) << "#endif" << endl;
-    }
-
-    cleanup_member_name_mapping(arg_struct);
-    scope_down(f_service_);
-    f_service_ << endl;
-
-    if (!(*f_iter)->is_oneway()) {
-      string resultname = (*f_iter)->get_name() + "_result";
-
-      t_struct noargs(program_);
-      t_function recv_function((*f_iter)->get_returntype(),
-                               string("recv_") + (*f_iter)->get_name(),
-                               &noargs,
-                               (*f_iter)->get_xceptions());
-      indent(f_service_) << "public " << function_signature(&recv_function) << endl;
-      scope_up(f_service_);
-
-      t_struct* xs = (*f_iter)->get_xceptions();
-      prepare_member_name_mapping(xs, xs->get_members(), resultname);
-
-      f_service_ << indent() << "TMessage msg = iprot_.ReadMessageBegin();" << endl << indent()
-                 << "if (msg.Type == TMessageType.Exception) {" << endl;
-      indent_up();
-      f_service_ << indent() << "TApplicationException x = TApplicationException.Read(iprot_);"
-                 << endl << indent() << "iprot_.ReadMessageEnd();" << endl << indent() << "throw x;"
-                 << endl;
-      indent_down();
-      f_service_ << indent() << "}" << endl << indent() << resultname << " result = new "
-                 << resultname << "();" << endl << indent() << "result.Read(iprot_);" << endl
-                 << indent() << "iprot_.ReadMessageEnd();" << endl;
-
-      if (!(*f_iter)->get_returntype()->is_void()) {
-        if (nullable_) {
-          if (type_can_be_null((*f_iter)->get_returntype())) {
-            f_service_ << indent() << "if (result.Success != null) {" << endl << indent()
-                       << "  return result.Success;" << endl << indent() << "}" << endl;
-          } else {
-            f_service_ << indent() << "if (result.Success.HasValue) {" << endl << indent()
-                       << "  return result.Success.Value;" << endl << indent() << "}" << endl;
-          }
-        } else {
-          f_service_ << indent() << "if (result.__isset.success) {" << endl << indent()
-                     << "  return result.Success;" << endl << indent() << "}" << endl;
-        }
-      }
-
-      const std::vector<t_field*>& xceptions = xs->get_members();
-      vector<t_field*>::const_iterator x_iter;
-      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-        if (nullable_) {
-          f_service_ << indent() << "if (result." << prop_name(*x_iter) << " != null) {" << endl
-                     << indent() << "  throw result." << prop_name(*x_iter) << ";" << endl
-                     << indent() << "}" << endl;
-        } else {
-          f_service_ << indent() << "if (result.__isset." << normalize_name((*x_iter)->get_name())
-                     << ") {" << endl << indent() << "  throw result." << prop_name(*x_iter) << ";"
-                     << endl << indent() << "}" << endl;
-        }
-      }
-
-      if ((*f_iter)->get_returntype()->is_void()) {
-        indent(f_service_) << "return;" << endl;
-      } else {
-        f_service_ << indent()
-                   << "throw new "
-                      "TApplicationException(TApplicationException.ExceptionType.MissingResult, \""
-                   << (*f_iter)->get_name() << " failed: unknown result\");" << endl;
-      }
-
-      cleanup_member_name_mapping((*f_iter)->get_xceptions());
-      scope_down(f_service_);
-      f_service_ << endl;
-    }
-  }
-
-  indent_down();
-  indent(f_service_) << "}" << endl;
-}
-
-void t_csharp_generator::generate_service_server(t_service* tservice) {
-  if (async_) {
-    generate_service_server_async(tservice);
-    generate_service_server_sync(tservice);
-  }
-  else {
-    generate_service_server_sync(tservice);
-  }
-}
-
-void t_csharp_generator::generate_service_server_sync(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-
-  string extends = "";
-  string extends_processor = "";
-  if (tservice->get_extends() != NULL) {
-    extends = type_name(tservice->get_extends());
-    extends_processor = extends + ".Processor, ";
-  }
-
-  indent(f_service_) << "public class Processor : " << extends_processor << "TProcessor {" << endl;
-  indent_up();
-
-  indent(f_service_) << "public Processor(ISync iface)";
-
-  if (!extends.empty()) {
-    f_service_ << " : base(iface)";
-  }
-  f_service_ << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "iface_ = iface;" << endl;
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    f_service_ << indent() << "processMap_[\"" << (*f_iter)->get_name()
-      << "\"] = " << (*f_iter)->get_name() << "_Process;" << endl;
-  }
-
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  if (extends.empty()) {
-    f_service_
-      << indent()
-      << "protected delegate void ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);"
-      << endl;
-  }
-
-  f_service_ << indent() << "private ISync iface_;" << endl;
-
-  if (extends.empty()) {
-    f_service_ << indent() << "protected Dictionary<string, ProcessFunction> processMap_ = new "
-      "Dictionary<string, ProcessFunction>();" << endl;
-  }
-
-  f_service_ << endl;
-
-  if (extends.empty()) {
-    indent(f_service_) << "public bool Process(TProtocol iprot, TProtocol oprot)" << endl;
-  }
-  else {
-    indent(f_service_) << "public new bool Process(TProtocol iprot, TProtocol oprot)" << endl;
-  }
-  scope_up(f_service_);
-
-  f_service_ << indent() << "try" << endl;
-  scope_up(f_service_);
-
-  f_service_ << indent() << "TMessage msg = iprot.ReadMessageBegin();" << endl;
-
-  f_service_
-    << indent() << "ProcessFunction fn;" << endl << indent()
-    << "processMap_.TryGetValue(msg.Name, out fn);" << endl << indent() << "if (fn == null) {"
-    << endl << indent() << "  TProtocolUtil.Skip(iprot, TType.Struct);" << endl << indent()
-    << "  iprot.ReadMessageEnd();" << endl << indent()
-    << "  TApplicationException x = new TApplicationException "
-    "(TApplicationException.ExceptionType.UnknownMethod, \"Invalid method name: '\" + "
-    "msg.Name + \"'\");" << endl << indent()
-    << "  oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));"
-    << endl << indent() << "  x.Write(oprot);" << endl << indent() << "  oprot.WriteMessageEnd();"
-    << endl << indent() << "  oprot.Transport.Flush();" << endl << indent() << "  return true;"
-    << endl << indent() << "}" << endl << indent() << "fn(msg.SeqID, iprot, oprot);" << endl;
-
-  scope_down(f_service_);
-
-  f_service_ << indent() << "catch (IOException)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "return false;" << endl;
-  scope_down(f_service_);
-
-  f_service_ << indent() << "return true;" << endl;
-
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_process_function(tservice, *f_iter);
-  }
-
-  indent_down();
-  indent(f_service_) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_service_server_async(t_service* tservice) {
-  vector<t_function*> functions = tservice->get_functions();
-  vector<t_function*>::iterator f_iter;
-
-  string extends = "";
-  string extends_processor = "";
-  if (tservice->get_extends() != NULL) {
-    extends = type_name(tservice->get_extends());
-    extends_processor = extends + ".Processor, ";
-  }
-
-  indent(f_service_) << "public class AsyncProcessor : " << extends_processor << "TAsyncProcessor {" << endl;
-  indent_up();
-
-  indent(f_service_) << "public AsyncProcessor(IAsync iface)";
-  if (!extends.empty()) {
-    f_service_ << " : base(iface)";
-  }
-  f_service_ << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "iface_ = iface;" << endl;
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    f_service_ << indent() << "processMap_[\"" << (*f_iter)->get_name()
-      << "\"] = " << (*f_iter)->get_name() << "_ProcessAsync;" << endl;
-  }
-
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  if (extends.empty()) {
-    f_service_
-      << indent()
-      << "protected delegate Task ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);"
-      << endl;
-  }
-
-  f_service_ << indent() << "private IAsync iface_;" << endl;
-
-  if (extends.empty()) {
-    f_service_ << indent() << "protected Dictionary<string, ProcessFunction> processMap_ = new "
-      "Dictionary<string, ProcessFunction>();" << endl;
-  }
-
-  f_service_ << endl;
-
-  if (extends.empty()) {
-    indent(f_service_) << "public async Task<bool> ProcessAsync(TProtocol iprot, TProtocol oprot)" << endl;
-  }
-  else {
-    indent(f_service_) << "public new async Task<bool> ProcessAsync(TProtocol iprot, TProtocol oprot)" << endl;
-  }
-  scope_up(f_service_);
-
-  f_service_ << indent() << "try" << endl;
-  scope_up(f_service_);
-
-  f_service_ << indent() << "TMessage msg = iprot.ReadMessageBegin();" << endl;
-
-  f_service_
-    << indent() << "ProcessFunction fn;" << endl << indent()
-    << "processMap_.TryGetValue(msg.Name, out fn);" << endl << indent() << "if (fn == null) {"
-    << endl << indent() << "  TProtocolUtil.Skip(iprot, TType.Struct);" << endl << indent()
-    << "  iprot.ReadMessageEnd();" << endl << indent()
-    << "  TApplicationException x = new TApplicationException "
-    "(TApplicationException.ExceptionType.UnknownMethod, \"Invalid method name: '\" + "
-    "msg.Name + \"'\");" << endl << indent()
-    << "  oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));"
-    << endl << indent() << "  x.Write(oprot);" << endl << indent() << "  oprot.WriteMessageEnd();"
-    << endl << indent() << "  oprot.Transport.Flush();" << endl << indent() << "  return true;"
-    << endl << indent() << "}" << endl << indent() << "await fn(msg.SeqID, iprot, oprot);" << endl;
-
-  scope_down(f_service_);
-
-  f_service_ << indent() << "catch (IOException)" << endl;
-  scope_up(f_service_);
-  f_service_ << indent() << "return false;" << endl;
-  scope_down(f_service_);
-
-  f_service_ << indent() << "return true;" << endl;
-
-  scope_down(f_service_);
-  f_service_ << endl;
-
-  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) {
-    generate_process_function_async(tservice, *f_iter);
-  }
-
-  indent_down();
-  indent(f_service_) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_function_helpers(t_function* tfunction) {
-  if (tfunction->is_oneway()) {
-    return;
-  }
-
-  t_struct result(program_, tfunction->get_name() + "_result");
-  t_field success(tfunction->get_returntype(), "success", 0);
-  if (!tfunction->get_returntype()->is_void()) {
-    result.append(&success);
-  }
-
-  t_struct* xs = tfunction->get_xceptions();
-  const vector<t_field*>& fields = xs->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    result.append(*f_iter);
-  }
-
-  generate_csharp_struct_definition(f_service_, &result, false, true, true);
-}
-
-void t_csharp_generator::generate_process_function(t_service* tservice, t_function* tfunction) {
-  (void)tservice;
-  indent(f_service_) << "public void " << tfunction->get_name()
-                     << "_Process(int seqid, TProtocol iprot, TProtocol oprot)" << endl;
-  scope_up(f_service_);
-
-  string argsname = tfunction->get_name() + "_args";
-  string resultname = tfunction->get_name() + "_result";
-
-  f_service_ << indent() << argsname << " args = new " << argsname << "();" << endl
-             << indent() << "args.Read(iprot);" << endl
-             << indent() << "iprot.ReadMessageEnd();" << endl;
-
-  t_struct* xs = tfunction->get_xceptions();
-  const std::vector<t_field*>& xceptions = xs->get_members();
-  vector<t_field*>::const_iterator x_iter;
-
-  if (!tfunction->is_oneway()) {
-    f_service_ << indent() << resultname << " result = new " << resultname << "();" << endl;
-  }
-
-  f_service_ << indent() << "try" << endl
-             << indent() << "{" << endl;
-  indent_up();
-
-  if (xceptions.size() > 0) {
-    f_service_ << indent() << "try" << endl
-               << indent() << "{" << endl;
-    indent_up();
-  }
-
-  t_struct* arg_struct = tfunction->get_arglist();
-  const std::vector<t_field*>& fields = arg_struct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  f_service_ << indent();
-  if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) {
-    f_service_ << "result.Success = ";
-  }
-  f_service_ << "iface_." << normalize_name(tfunction->get_name()) << "(";
-  bool first = true;
-  prepare_member_name_mapping(arg_struct);
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      f_service_ << ", ";
-    }
-    f_service_ << "args." << prop_name(*f_iter);
-    if (nullable_ && !type_can_be_null((*f_iter)->get_type())) {
-      f_service_ << ".Value";
-    }
-  }
-  cleanup_member_name_mapping(arg_struct);
-  f_service_ << ");" << endl;
-
-  prepare_member_name_mapping(xs, xs->get_members(), resultname);
-  if (xceptions.size() > 0) {
-    indent_down();
-    f_service_ << indent() << "}" << endl;
-    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-      f_service_ << indent() << "catch (" << type_name((*x_iter)->get_type(), false, false) << " "
-                 << (*x_iter)->get_name() << ")" << endl
-                 << indent() << "{" << endl;
-      if (!tfunction->is_oneway()) {
-        indent_up();
-        f_service_ << indent() << "result." << prop_name(*x_iter) << " = " << (*x_iter)->get_name()
-                   << ";" << endl;
-        indent_down();
-      }
-      f_service_ << indent() << "}" << endl;
-    }
-  }
-  if (!tfunction->is_oneway()) {
-    f_service_ << indent() << "oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name()
-               << "\", TMessageType.Reply, seqid)); " << endl;
-    f_service_ << indent() << "result.Write(oprot);" << endl;
-  }
-  indent_down();
-
-  cleanup_member_name_mapping(xs);
-
-  f_service_ << indent() << "}" << endl
-             << indent() << "catch (TTransportException)" << endl
-             << indent() << "{" << endl
-             << indent() << "  throw;" << endl
-             << indent() << "}" << endl
-             << indent() << "catch (Exception ex)" << endl
-             << indent() << "{" << endl
-             << indent() << "  Console.Error.WriteLine(\"Error occurred in processor:\");" << endl
-             << indent() << "  Console.Error.WriteLine(ex.ToString());" << endl;
-
-  if (tfunction->is_oneway()) {
-    f_service_ << indent() << "}" << endl;
-  } else {
-    f_service_ << indent() << "  TApplicationException x = new TApplicationException" << indent()
-               << "(TApplicationException.ExceptionType.InternalError,\" Internal error.\");"
-               << endl
-               << indent() << "  oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name()
-               << "\", TMessageType.Exception, seqid));" << endl
-               << indent() << "  x.Write(oprot);" << endl
-               << indent() << "}" << endl;
-    f_service_ << indent() << "oprot.WriteMessageEnd();" << endl
-               << indent() << "oprot.Transport.Flush();" << endl;
-  }
-
-  scope_down(f_service_);
-
-  f_service_ << endl;
-}
-
-void t_csharp_generator::generate_process_function_async(t_service* tservice, t_function* tfunction) {
-  (void)tservice;
-  indent(f_service_) << "public async Task " << tfunction->get_name()
-    << "_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot)" << endl;
-  scope_up(f_service_);
-
-  string argsname = tfunction->get_name() + "_args";
-  string resultname = tfunction->get_name() + "_result";
-
-  f_service_ << indent() << argsname << " args = new " << argsname << "();" << endl
-    << indent() << "args.Read(iprot);" << endl
-    << indent() << "iprot.ReadMessageEnd();" << endl;
-
-  t_struct* xs = tfunction->get_xceptions();
-  const std::vector<t_field*>& xceptions = xs->get_members();
-  vector<t_field*>::const_iterator x_iter;
-
-  if (!tfunction->is_oneway()) {
-    f_service_ << indent() << resultname << " result = new " << resultname << "();" << endl;
-  }
-
-  f_service_ << indent() << "try" << endl
-    << indent() << "{" << endl;
-  indent_up();
-
-  if (xceptions.size() > 0) {
-    f_service_ << indent() << "try" << endl
-      << indent() << "{" << endl;
-    indent_up();
-  }
-
-  t_struct* arg_struct = tfunction->get_arglist();
-  const std::vector<t_field*>& fields = arg_struct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  f_service_ << indent();
-  if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) {
-    f_service_ << "result.Success = ";
-  }
-  f_service_ << "await iface_." << normalize_name(tfunction->get_name()) << "Async(";
-  bool first = true;
-  prepare_member_name_mapping(arg_struct);
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    }
-    else {
-      f_service_ << ", ";
-    }
-    f_service_ << "args." << prop_name(*f_iter);
-    if (nullable_ && !type_can_be_null((*f_iter)->get_type())) {
-      f_service_ << ".Value";
-    }
-  }
-  cleanup_member_name_mapping(arg_struct);
-  f_service_ << ");" << endl;
-
-  prepare_member_name_mapping(xs, xs->get_members(), resultname);
-  if (xceptions.size() > 0) {
-    indent_down();
-    f_service_ << indent() << "}" << endl;
-    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) {
-      f_service_ << indent() << "catch (" << type_name((*x_iter)->get_type(), false, false) << " "
-        << (*x_iter)->get_name() << ")" << endl
-        << indent() << "{" << endl;
-      if (!tfunction->is_oneway()) {
-        indent_up();
-        f_service_ << indent() << "result." << prop_name(*x_iter) << " = " << (*x_iter)->get_name()
-          << ";" << endl;
-        indent_down();
-      }
-      f_service_ << indent() << "}" << endl;
-    }
-  }
-  if (!tfunction->is_oneway()) {
-    f_service_ << indent() << "oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name()
-      << "\", TMessageType.Reply, seqid)); " << endl;
-    f_service_ << indent() << "result.Write(oprot);" << endl;
-  }
-  indent_down();
-
-  cleanup_member_name_mapping(xs);
-
-  f_service_ << indent() << "}" << endl
-    << indent() << "catch (TTransportException)" << endl
-    << indent() << "{" << endl
-    << indent() << "  throw;" << endl
-    << indent() << "}" << endl
-    << indent() << "catch (Exception ex)" << endl
-    << indent() << "{" << endl
-    << indent() << "  Console.Error.WriteLine(\"Error occurred in processor:\");" << endl
-    << indent() << "  Console.Error.WriteLine(ex.ToString());" << endl;
-
-  if (tfunction->is_oneway()) {
-    f_service_ << indent() << "}" << endl;
-  }
-  else {
-    f_service_ << indent() << "  TApplicationException x = new TApplicationException" << indent()
-      << "(TApplicationException.ExceptionType.InternalError,\" Internal error.\");"
-      << endl
-      << indent() << "  oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name()
-      << "\", TMessageType.Exception, seqid));" << endl
-      << indent() << "  x.Write(oprot);" << endl
-      << indent() << "}" << endl;
-    f_service_ << indent() << "oprot.WriteMessageEnd();" << endl
-      << indent() << "oprot.Transport.Flush();" << endl;
-  }
-
-  scope_down(f_service_);
-
-  f_service_ << endl;
-}
-
-void t_csharp_generator::generate_csharp_union_reader(std::ostream& out, t_struct* tunion) {
-  // Thanks to THRIFT-1768, we don't need to check for required fields in the union
-  const vector<t_field*>& fields = tunion->get_members();
-  vector<t_field*>::const_iterator f_iter;
-
-  indent(out) << "public static " << tunion->get_name() << " Read(TProtocol iprot)" << endl;
-  scope_up(out);
-
-  out << indent() << "iprot.IncrementRecursionDepth();" << endl;
-  out << indent() << "try" << endl;
-  scope_up(out);
-
-  indent(out) << tunion->get_name() << " retval;" << endl;
-  indent(out) << "iprot.ReadStructBegin();" << endl;
-  indent(out) << "TField field = iprot.ReadFieldBegin();" << endl;
-  // we cannot have the first field be a stop -- we must have a single field defined
-  indent(out) << "if (field.Type == TType.Stop)" << endl;
-  scope_up(out);
-  indent(out) << "iprot.ReadFieldEnd();" << endl;
-  indent(out) << "retval = new ___undefined();" << endl;
-  scope_down(out);
-  indent(out) << "else" << endl;
-  scope_up(out);
-  indent(out) << "switch (field.ID)" << endl;
-  scope_up(out);
-
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl;
-    indent_up();
-    indent(out) << "if (field.Type == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl;
-    indent_up();
-
-    indent(out) << type_name((*f_iter)->get_type()) << " temp;" << endl;
-    generate_deserialize_field(out, (*f_iter), "temp", true);
-    indent(out) << "retval = new " << (*f_iter)->get_name() << "(temp);" << endl;
-
-    indent_down();
-    out << indent() << "} else { " << endl << indent() << "  TProtocolUtil.Skip(iprot, field.Type);"
-        << endl << indent() << "  retval = new ___undefined();" << endl << indent() << "}" << endl
-        << indent() << "break;" << endl;
-    indent_down();
-  }
-
-  indent(out) << "default: " << endl;
-  indent_up();
-  indent(out) << "TProtocolUtil.Skip(iprot, field.Type);" << endl << indent()
-              << "retval = new ___undefined();" << endl;
-  indent(out) << "break;" << endl;
-  indent_down();
-
-  scope_down(out);
-
-  indent(out) << "iprot.ReadFieldEnd();" << endl;
-
-  indent(out) << "if (iprot.ReadFieldBegin().Type != TType.Stop)" << endl;
-  scope_up(out);
-  indent(out) << "throw new TProtocolException(TProtocolException.INVALID_DATA);" << endl;
-  scope_down(out);
-
-  // end of else for TStop
-  scope_down(out);
-  indent(out) << "iprot.ReadStructEnd();" << endl;
-  indent(out) << "return retval;" << endl;
-  indent_down();
-
-  scope_down(out);
-  out << indent() << "finally" << endl;
-  scope_up(out);
-  out << indent() << "iprot.DecrementRecursionDepth();" << endl;
-  scope_down(out);
-
-  indent(out) << "}" << endl << endl;
-}
-
-void t_csharp_generator::generate_deserialize_field(ostream& out,
-                                                    t_field* tfield,
-                                                    string prefix,
-                                                    bool is_propertyless) {
-  t_type* type = tfield->get_type();
-  while (type->is_typedef()) {
-    type = ((t_typedef*)type)->get_type();
-  }
-
-  if (type->is_void()) {
-    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name();
-  }
-
-  string name = prefix + (is_propertyless ? "" : prop_name(tfield));
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_deserialize_struct(out, (t_struct*)type, name);
-  } else if (type->is_container()) {
-    generate_deserialize_container(out, type, name);
-  } else if (type->is_base_type() || type->is_enum()) {
-    indent(out) << name << " = ";
-
-    if (type->is_enum()) {
-      out << "(" << type_name(type, false, true) << ")";
-    }
-
-    out << "iprot.";
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + name;
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "ReadBinary();";
-        } else {
-          out << "ReadString();";
-        }
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "ReadBool();";
-        break;
-      case t_base_type::TYPE_I8:
-        out << "ReadByte();";
-        break;
-      case t_base_type::TYPE_I16:
-        out << "ReadI16();";
-        break;
-      case t_base_type::TYPE_I32:
-        out << "ReadI32();";
-        break;
-      case t_base_type::TYPE_I64:
-        out << "ReadI64();";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "ReadDouble();";
-        break;
-      default:
-        throw "compiler error: no C# name for base type " + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      out << "ReadI32();";
-    }
-    out << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n",
-           tfield->get_name().c_str(),
-           type_name(type).c_str());
-  }
-}
-
-void t_csharp_generator::generate_deserialize_struct(ostream& out,
-                                                     t_struct* tstruct,
-                                                     string prefix) {
-  if (union_ && tstruct->is_union()) {
-    out << indent() << prefix << " = " << type_name(tstruct) << ".Read(iprot);" << endl;
-  } else {
-    out << indent() << prefix << " = new " << type_name(tstruct) << "();" << endl << indent()
-        << prefix << ".Read(iprot);" << endl;
-  }
-}
-
-void t_csharp_generator::generate_deserialize_container(ostream& out,
-                                                        t_type* ttype,
-                                                        string prefix) {
-  scope_up(out);
-
-  string obj;
-
-  if (ttype->is_map()) {
-    obj = tmp("_map");
-  } else if (ttype->is_set()) {
-    obj = tmp("_set");
-  } else if (ttype->is_list()) {
-    obj = tmp("_list");
-  }
-
-  indent(out) << prefix << " = new " << type_name(ttype, false, true) << "();" << endl;
-  if (ttype->is_map()) {
-    out << indent() << "TMap " << obj << " = iprot.ReadMapBegin();" << endl;
-  } else if (ttype->is_set()) {
-    out << indent() << "TSet " << obj << " = iprot.ReadSetBegin();" << endl;
-  } else if (ttype->is_list()) {
-    out << indent() << "TList " << obj << " = iprot.ReadListBegin();" << endl;
-  }
-
-  string i = tmp("_i");
-  indent(out) << "for( int " << i << " = 0; " << i << " < " << obj << ".Count"
-              << "; "
-              << "++" << i << ")" << endl;
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    generate_deserialize_map_element(out, (t_map*)ttype, prefix);
-  } else if (ttype->is_set()) {
-    generate_deserialize_set_element(out, (t_set*)ttype, prefix);
-  } else if (ttype->is_list()) {
-    generate_deserialize_list_element(out, (t_list*)ttype, prefix);
-  }
-
-  scope_down(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "iprot.ReadMapEnd();" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "iprot.ReadSetEnd();" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "iprot.ReadListEnd();" << endl;
-  }
-
-  scope_down(out);
-}
-
-void t_csharp_generator::generate_deserialize_map_element(ostream& out,
-                                                          t_map* tmap,
-                                                          string prefix) {
-  string key = tmp("_key");
-  string val = tmp("_val");
-
-  t_field fkey(tmap->get_key_type(), key);
-  t_field fval(tmap->get_val_type(), val);
-
-  indent(out) << declare_field(&fkey) << endl;
-  indent(out) << declare_field(&fval) << endl;
-
-  generate_deserialize_field(out, &fkey);
-  generate_deserialize_field(out, &fval);
-
-  indent(out) << prefix << "[" << key << "] = " << val << ";" << endl;
-}
-
-void t_csharp_generator::generate_deserialize_set_element(ostream& out,
-                                                          t_set* tset,
-                                                          string prefix) {
-  string elem = tmp("_elem");
-  t_field felem(tset->get_elem_type(), elem);
-
-  indent(out) << declare_field(&felem) << endl;
-
-  generate_deserialize_field(out, &felem);
-
-  indent(out) << prefix << ".Add(" << elem << ");" << endl;
-}
-
-void t_csharp_generator::generate_deserialize_list_element(ostream& out,
-                                                           t_list* tlist,
-                                                           string prefix) {
-  string elem = tmp("_elem");
-  t_field felem(tlist->get_elem_type(), elem);
-
-  indent(out) << declare_field(&felem) << endl;
-
-  generate_deserialize_field(out, &felem);
-
-  indent(out) << prefix << ".Add(" << elem << ");" << endl;
-}
-
-void t_csharp_generator::generate_serialize_field(ostream& out,
-                                                  t_field* tfield,
-                                                  string prefix,
-                                                  bool is_element,
-                                                  bool is_propertyless) {
-  t_type* type = tfield->get_type();
-  while (type->is_typedef()) {
-    type = ((t_typedef*)type)->get_type();
-  }
-
-  string name = prefix + (is_propertyless ? "" : prop_name(tfield));
-
-  if (type->is_void()) {
-    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + name;
-  }
-
-  if (type->is_struct() || type->is_xception()) {
-    generate_serialize_struct(out, (t_struct*)type, name);
-  } else if (type->is_container()) {
-    generate_serialize_container(out, type, name);
-  } else if (type->is_base_type() || type->is_enum()) {
-    indent(out) << "oprot.";
-
-    string nullable_name = nullable_ && !is_element && !field_is_required(tfield) ? name + ".Value"
-                                                                                  : name;
-
-    if (type->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "compiler error: cannot serialize void field in a struct: " + name;
-        break;
-      case t_base_type::TYPE_STRING:
-        if (type->is_binary()) {
-          out << "WriteBinary(";
-        } else {
-          out << "WriteString(";
-        }
-        out << name << ");";
-        break;
-      case t_base_type::TYPE_BOOL:
-        out << "WriteBool(" << nullable_name << ");";
-        break;
-      case t_base_type::TYPE_I8:
-        out << "WriteByte(" << nullable_name << ");";
-        break;
-      case t_base_type::TYPE_I16:
-        out << "WriteI16(" << nullable_name << ");";
-        break;
-      case t_base_type::TYPE_I32:
-        out << "WriteI32(" << nullable_name << ");";
-        break;
-      case t_base_type::TYPE_I64:
-        out << "WriteI64(" << nullable_name << ");";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        out << "WriteDouble(" << nullable_name << ");";
-        break;
-      default:
-        throw "compiler error: no C# name for base type " + t_base_type::t_base_name(tbase);
-      }
-    } else if (type->is_enum()) {
-      out << "WriteI32((int)" << nullable_name << ");";
-    }
-    out << endl;
-  } else {
-    printf("DO NOT KNOW HOW TO SERIALIZE '%s%s' TYPE '%s'\n",
-           prefix.c_str(),
-           tfield->get_name().c_str(),
-           type_name(type).c_str());
-  }
-}
-
-void t_csharp_generator::generate_serialize_struct(ostream& out,
-                                                   t_struct* tstruct,
-                                                   string prefix) {
-  (void)tstruct;
-  out << indent() << prefix << ".Write(oprot);" << endl;
-}
-
-void t_csharp_generator::generate_serialize_container(ostream& out, t_type* ttype, string prefix) {
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "oprot.WriteMapBegin(new TMap(" << type_to_enum(((t_map*)ttype)->get_key_type())
-                << ", " << type_to_enum(((t_map*)ttype)->get_val_type()) << ", " << prefix
-                << ".Count));" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "oprot.WriteSetBegin(new TSet(" << type_to_enum(((t_set*)ttype)->get_elem_type())
-                << ", " << prefix << ".Count));" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "oprot.WriteListBegin(new TList("
-                << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", " << prefix << ".Count));"
-                << endl;
-  }
-
-  string iter = tmp("_iter");
-  if (ttype->is_map()) {
-    indent(out) << "foreach (" << type_name(((t_map*)ttype)->get_key_type()) << " " << iter
-                << " in " << prefix << ".Keys)";
-  } else if (ttype->is_set()) {
-    indent(out) << "foreach (" << type_name(((t_set*)ttype)->get_elem_type()) << " " << iter
-                << " in " << prefix << ")";
-  } else if (ttype->is_list()) {
-    indent(out) << "foreach (" << type_name(((t_list*)ttype)->get_elem_type()) << " " << iter
-                << " in " << prefix << ")";
-  }
-
-  out << endl;
-  scope_up(out);
-
-  if (ttype->is_map()) {
-    generate_serialize_map_element(out, (t_map*)ttype, iter, prefix);
-  } else if (ttype->is_set()) {
-    generate_serialize_set_element(out, (t_set*)ttype, iter);
-  } else if (ttype->is_list()) {
-    generate_serialize_list_element(out, (t_list*)ttype, iter);
-  }
-
-  scope_down(out);
-
-  if (ttype->is_map()) {
-    indent(out) << "oprot.WriteMapEnd();" << endl;
-  } else if (ttype->is_set()) {
-    indent(out) << "oprot.WriteSetEnd();" << endl;
-  } else if (ttype->is_list()) {
-    indent(out) << "oprot.WriteListEnd();" << endl;
-  }
-
-  scope_down(out);
-}
-
-void t_csharp_generator::generate_serialize_map_element(ostream& out,
-                                                        t_map* tmap,
-                                                        string iter,
-                                                        string map) {
-  t_field kfield(tmap->get_key_type(), iter);
-  generate_serialize_field(out, &kfield, "", true);
-  t_field vfield(tmap->get_val_type(), map + "[" + iter + "]");
-  generate_serialize_field(out, &vfield, "", true);
-}
-
-void t_csharp_generator::generate_serialize_set_element(ostream& out, t_set* tset, string iter) {
-  t_field efield(tset->get_elem_type(), iter);
-  generate_serialize_field(out, &efield, "", true);
-}
-
-void t_csharp_generator::generate_serialize_list_element(ostream& out,
-                                                         t_list* tlist,
-                                                         string iter) {
-  t_field efield(tlist->get_elem_type(), iter);
-  generate_serialize_field(out, &efield, "", true);
-}
-
-void t_csharp_generator::generate_property(ostream& out,
-                                           t_field* tfield,
-                                           bool isPublic,
-                                           bool generateIsset) {
-  generate_csharp_property(out, tfield, isPublic, generateIsset, "_");
-}
-void t_csharp_generator::generate_csharp_property(ostream& out,
-                                                  t_field* tfield,
-                                                  bool isPublic,
-                                                  bool generateIsset,
-                                                  std::string fieldPrefix) {
-  if ((serialize_ || wcf_) && isPublic) {
-    indent(out) << "[DataMember(Order = 0)]" << endl;
-  }
-  bool has_default = field_has_default(tfield);
-  bool is_required = field_is_required(tfield);
-  if ((nullable_ && !has_default) || (is_required)) {
-    indent(out) << (isPublic ? "public " : "private ")
-                << type_name(tfield->get_type(), false, false, true, is_required) << " "
-                << prop_name(tfield) << " { get; set; }" << endl;
-  } else {
-    indent(out) << (isPublic ? "public " : "private ")
-                << type_name(tfield->get_type(), false, false, true) << " " << prop_name(tfield)
-                << endl;
-    scope_up(out);
-    indent(out) << "get" << endl;
-    scope_up(out);
-    bool use_nullable = false;
-    if (nullable_) {
-      t_type* ttype = tfield->get_type();
-      while (ttype->is_typedef()) {
-        ttype = ((t_typedef*)ttype)->get_type();
-      }
-      if (ttype->is_base_type()) {
-        use_nullable = ((t_base_type*)ttype)->get_base() != t_base_type::TYPE_STRING;
-      } else if (ttype->is_enum()) {
-        use_nullable = true;
-      }
-    }
-    indent(out) << "return " << fieldPrefix + tfield->get_name() << ";" << endl;
-    scope_down(out);
-    indent(out) << "set" << endl;
-    scope_up(out);
-    if (use_nullable) {
-      if (generateIsset) {
-        indent(out) << "__isset." << normalize_name(tfield->get_name()) << " = value.HasValue;"
-                    << endl;
-      }
-      indent(out) << "if (value.HasValue) this." << fieldPrefix + tfield->get_name()
-                  << " = value.Value;" << endl;
-    } else {
-      if (generateIsset) {
-        indent(out) << "__isset." << normalize_name(tfield->get_name()) << " = true;" << endl;
-      }
-      indent(out) << "this." << fieldPrefix + tfield->get_name() << " = value;" << endl;
-    }
-    scope_down(out);
-    scope_down(out);
-  }
-  out << endl;
-}
-
-std::string t_csharp_generator::make_valid_csharp_identifier(std::string const& fromName) {
-  std::string str = fromName;
-  if (str.empty()) {
-    return str;
-  }
-
-  // tests rely on this
-  assert(('A' < 'Z') && ('a' < 'z') && ('0' < '9'));
-
-  // if the first letter is a number, we add an additional underscore in front of it
-  char c = str.at(0);
-  if (('0' <= c) && (c <= '9')) {
-    str = "_" + str;
-  }
-
-  // following chars: letter, number or underscore
-  for (size_t i = 0; i < str.size(); ++i) {
-    c = str.at(i);
-    if ((('A' > c) || (c > 'Z')) && (('a' > c) || (c > 'z')) && (('0' > c) || (c > '9'))
-        && ('_' != c)) {
-      str.replace(i, 1, "_");
-    }
-  }
-
-  return str;
-}
-
-void t_csharp_generator::cleanup_member_name_mapping(void* scope) {
-  if( member_mapping_scopes.empty()) {
-    throw "internal error: cleanup_member_name_mapping() no scope active";
-  }
-
-  member_mapping_scope& active = member_mapping_scopes.back();
-  if (active.scope_member != scope) {
-    throw "internal error: cleanup_member_name_mapping() called for wrong struct";
-  }
-
-  member_mapping_scopes.pop_back();
-}
-
-string t_csharp_generator::get_mapped_member_name(string name) {
-  if( ! member_mapping_scopes.empty()) {
-    member_mapping_scope& active = member_mapping_scopes.back();
-    map<string, string>::iterator iter = active.mapping_table.find(name);
-    if (active.mapping_table.end() != iter) {
-      return iter->second;
-    }
-  }
-
-  pverbose("no mapping for member %s\n", name.c_str());
-  return name;
-}
-
-void t_csharp_generator::prepare_member_name_mapping(t_struct* tstruct) {
-  prepare_member_name_mapping(tstruct, tstruct->get_members(), tstruct->get_name());
-}
-
-void t_csharp_generator::prepare_member_name_mapping(void* scope,
-                                                     const vector<t_field*>& members,
-                                                     const string& structname) {
-  // begin new scope
-  member_mapping_scope dummy;
-  dummy.scope_member = 0;
-  member_mapping_scopes.push_back(dummy);
-  member_mapping_scope& active = member_mapping_scopes.back();
-  active.scope_member = scope;
-
-  // current C# generator policy:
-  // - prop names are always rendered with an Uppercase first letter
-  // - struct names are used as given
-  std::set<std::string> used_member_names;
-  vector<t_field*>::const_iterator iter;
-
-  // prevent name conflicts with struct (CS0542 error)
-  used_member_names.insert(structname);
-
-  // prevent name conflicts with known methods (THRIFT-2942)
-  used_member_names.insert("Read");
-  used_member_names.insert("Write");
-
-  for (iter = members.begin(); iter != members.end(); ++iter) {
-    string oldname = (*iter)->get_name();
-    string newname = prop_name(*iter, true);
-    while (true) {
-
-      // new name conflicts with another member
-      if (used_member_names.find(newname) != used_member_names.end()) {
-        pverbose("struct %s: member %s conflicts with another member\n",
-                 structname.c_str(),
-                 newname.c_str());
-        newname += '_';
-        continue;
-      }
-
-      // add always, this helps us to detect edge cases like
-      // different spellings ("foo" and "Foo") within the same struct
-      pverbose("struct %s: member mapping %s => %s\n",
-               structname.c_str(),
-               oldname.c_str(),
-               newname.c_str());
-      active.mapping_table[oldname] = newname;
-      used_member_names.insert(newname);
-      break;
-    }
-  }
-}
-
-std::string t_csharp_generator::prop_name(t_field* tfield, bool suppress_mapping) {
-  string name(tfield->get_name());
-  if (suppress_mapping) {
-    name[0] = toupper(name[0]);
-  } else {
-    name = get_mapped_member_name(name);
-  }
-  return name;
-}
-
-string t_csharp_generator::type_name(t_type* ttype,
-                                     bool in_container,
-                                     bool in_init,
-                                     bool in_param,
-                                     bool is_required) {
-  (void)in_init;
-  while (ttype->is_typedef()) {
-    ttype = ((t_typedef*)ttype)->get_type();
-  }
-
-  if (ttype->is_base_type()) {
-    return base_type_name((t_base_type*)ttype, in_container, in_param, is_required);
-  } else if (ttype->is_map()) {
-    t_map* tmap = (t_map*)ttype;
-    return "Dictionary<" + type_name(tmap->get_key_type(), true) + ", "
-           + type_name(tmap->get_val_type(), true) + ">";
-  } else if (ttype->is_set()) {
-    t_set* tset = (t_set*)ttype;
-    return "THashSet<" + type_name(tset->get_elem_type(), true) + ">";
-  } else if (ttype->is_list()) {
-    t_list* tlist = (t_list*)ttype;
-    return "List<" + type_name(tlist->get_elem_type(), true) + ">";
-  }
-
-  t_program* program = ttype->get_program();
-  string postfix = (!is_required && nullable_ && in_param && ttype->is_enum()) ? "?" : "";
-  if (program != NULL && program != program_) {
-    string ns = program->get_namespace("csharp");
-    if (!ns.empty()) {
-      return ns + "." + normalize_name(ttype->get_name()) + postfix;
-    }
-  }
-
-  return normalize_name(ttype->get_name()) + postfix;
-}
-
-string t_csharp_generator::base_type_name(t_base_type* tbase,
-                                          bool in_container,
-                                          bool in_param,
-                                          bool is_required) {
-  (void)in_container;
-  string postfix = (!is_required && nullable_ && in_param) ? "?" : "";
-  switch (tbase->get_base()) {
-  case t_base_type::TYPE_VOID:
-    return "void";
-  case t_base_type::TYPE_STRING:
-    if (tbase->is_binary()) {
-      return "byte[]";
-    } else {
-      return "string";
-    }
-  case t_base_type::TYPE_BOOL:
-    return "bool" + postfix;
-  case t_base_type::TYPE_I8:
-    return "sbyte" + postfix;
-  case t_base_type::TYPE_I16:
-    return "short" + postfix;
-  case t_base_type::TYPE_I32:
-    return "int" + postfix;
-  case t_base_type::TYPE_I64:
-    return "long" + postfix;
-  case t_base_type::TYPE_DOUBLE:
-    return "double" + postfix;
-  default:
-    throw "compiler error: no C# name for base type " + t_base_type::t_base_name(tbase->get_base());
-  }
-}
-
-string t_csharp_generator::declare_field(t_field* tfield, bool init, std::string prefix) {
-  string result = type_name(tfield->get_type()) + " " + prefix + tfield->get_name();
-  if (init) {
-    t_type* ttype = tfield->get_type();
-    while (ttype->is_typedef()) {
-      ttype = ((t_typedef*)ttype)->get_type();
-    }
-    if (ttype->is_base_type() && field_has_default(tfield)) {
-      std::ofstream dummy;
-      result += " = " + render_const_value(dummy, tfield->get_name(), ttype, tfield->get_value());
-    } else if (ttype->is_base_type()) {
-      t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base();
-      switch (tbase) {
-      case t_base_type::TYPE_VOID:
-        throw "NO T_VOID CONSTRUCT";
-      case t_base_type::TYPE_STRING:
-        result += " = null";
-        break;
-      case t_base_type::TYPE_BOOL:
-        result += " = false";
-        break;
-      case t_base_type::TYPE_I8:
-      case t_base_type::TYPE_I16:
-      case t_base_type::TYPE_I32:
-      case t_base_type::TYPE_I64:
-        result += " = 0";
-        break;
-      case t_base_type::TYPE_DOUBLE:
-        result += " = (double)0";
-        break;
-      }
-    } else if (ttype->is_enum()) {
-      result += " = (" + type_name(ttype, false, true) + ")0";
-    } else if (ttype->is_container()) {
-      result += " = new " + type_name(ttype, false, true) + "()";
-    } else {
-      result += " = new " + type_name(ttype, false, true) + "()";
-    }
-  }
-  return result + ";";
-}
-
-string t_csharp_generator::function_signature(t_function* tfunction, string prefix) {
-  t_type* ttype = tfunction->get_returntype();
-  return type_name(ttype) + " " + normalize_name(prefix + tfunction->get_name()) + "("
-         + argument_list(tfunction->get_arglist()) + ")";
-}
-
-string t_csharp_generator::function_signature_async_begin(t_function* tfunction, string prefix) {
-  string comma = (tfunction->get_arglist()->get_members().size() > 0 ? ", " : "");
-  return "IAsyncResult " + normalize_name(prefix + tfunction->get_name())
-         + "(AsyncCallback callback, object state" + comma + argument_list(tfunction->get_arglist())
-         + ")";
-}
-
-string t_csharp_generator::function_signature_async_end(t_function* tfunction, string prefix) {
-  t_type* ttype = tfunction->get_returntype();
-  return type_name(ttype) + " " + normalize_name(prefix + tfunction->get_name())
-         + "(IAsyncResult asyncResult)";
-}
-
-string t_csharp_generator::function_signature_async(t_function* tfunction, string prefix) {
-  t_type* ttype = tfunction->get_returntype();
-  string task = "Task";
-  if (!ttype->is_void())
-    task += "<" + type_name(ttype) + ">";
-  return task + " " + normalize_name(prefix + tfunction->get_name()) + "Async("
-         + argument_list(tfunction->get_arglist()) + ")";
-}
-
-string t_csharp_generator::argument_list(t_struct* tstruct) {
-  string result = "";
-  const vector<t_field*>& fields = tstruct->get_members();
-  vector<t_field*>::const_iterator f_iter;
-  bool first = true;
-  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) {
-    if (first) {
-      first = false;
-    } else {
-      result += ", ";
-    }
-    result += type_name((*f_iter)->get_type()) + " " + normalize_name((*f_iter)->get_name());
-  }
-  return result;
-}
-
-string t_csharp_generator::type_to_enum(t_type* type) {
-  while (type->is_typedef()) {
-    type = ((t_typedef*)type)->get_type();
-  }
-
-  if (type->is_base_type()) {
-    t_base_type::t_base tbase = ((t_base_type*)type)->get_base();
-    switch (tbase) {
-    case t_base_type::TYPE_VOID:
-      throw "NO T_VOID CONSTRUCT";
-    case t_base_type::TYPE_STRING:
-      return "TType.String";
-    case t_base_type::TYPE_BOOL:
-      return "TType.Bool";
-    case t_base_type::TYPE_I8:
-      return "TType.Byte";
-    case t_base_type::TYPE_I16:
-      return "TType.I16";
-    case t_base_type::TYPE_I32:
-      return "TType.I32";
-    case t_base_type::TYPE_I64:
-      return "TType.I64";
-    case t_base_type::TYPE_DOUBLE:
-      return "TType.Double";
-    }
-  } else if (type->is_enum()) {
-    return "TType.I32";
-  } else if (type->is_struct() || type->is_xception()) {
-    return "TType.Struct";
-  } else if (type->is_map()) {
-    return "TType.Map";
-  } else if (type->is_set()) {
-    return "TType.Set";
-  } else if (type->is_list()) {
-    return "TType.List";
-  }
-
-  throw "INVALID TYPE IN type_to_enum: " + type->get_name();
-}
-
-void t_csharp_generator::generate_csharp_docstring_comment(ostream& out, string contents) {
-  generate_docstring_comment(out, "/// <summary>\n", "/// ", contents, "/// </summary>\n");
-}
-
-void t_csharp_generator::generate_csharp_doc(ostream& out, t_field* field) {
-  if (field->get_type()->is_enum()) {
-    string combined_message = field->get_doc() + "\n<seealso cref=\""
-                              + get_enum_class_name(field->get_type()) + "\"/>";
-    generate_csharp_docstring_comment(out, combined_message);
-  } else {
-    generate_csharp_doc(out, (t_doc*)field);
-  }
-}
-
-void t_csharp_generator::generate_csharp_doc(ostream& out, t_doc* tdoc) {
-  if (tdoc->has_doc()) {
-    generate_csharp_docstring_comment(out, tdoc->get_doc());
-  }
-}
-
-void t_csharp_generator::generate_csharp_doc(ostream& out, t_function* tfunction) {
-  if (tfunction->has_doc()) {
-    stringstream ps;
-    const vector<t_field*>& fields = tfunction->get_arglist()->get_members();
-    vector<t_field*>::const_iterator p_iter;
-    for (p_iter = fields.begin(); p_iter != fields.end(); ++p_iter) {
-      t_field* p = *p_iter;
-      ps << "\n<param name=\"" << p->get_name() << "\">";
-      if (p->has_doc()) {
-        std::string str = p->get_doc();
-        str.erase(std::remove(str.begin(), str.end(), '\n'),
-                  str.end()); // remove the newlines that appear from the parser
-        ps << str;
-      }
-      ps << "</param>";
-    }
-    generate_docstring_comment(out,
-                               "",
-                               "/// ",
-                               "<summary>\n" + tfunction->get_doc() + "</summary>" + ps.str(),
-                               "");
-  }
-}
-
-std::string t_csharp_generator::get_enum_class_name(t_type* type) {
-  string package = "";
-  t_program* program = type->get_program();
-  if (program != NULL && program != program_) {
-    package = program->get_namespace("csharp") + ".";
-  }
-  return package + type->get_name();
-}
-
-
-THRIFT_REGISTER_GENERATOR(
-    csharp,
-    "C#",
-    "    async:           Adds Async support using Task.Run.\n"
-    "    wcf:             Adds bindings for WCF to generated classes.\n"
-    "    serial:          Add serialization support to generated classes.\n"
-    "    nullable:        Use nullable types for properties.\n"
-    "    hashcode:        Generate a hashcode and equals implementation for classes.\n"
-    "    union:           Use new union typing, which includes a static read function for union "
-    "types.\n")
+/* 
+ * 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. 
+ * 
+ * Contains some contributions under the Thrift Software License. 
+ * Please see doc/old-thrift-license.txt in the Thrift distribution for 
+ * details. 
+ */ 
+ 
+#include <cassert> 
+ 
+#include <string> 
+#include <fstream> 
+#include <iostream> 
+#include <vector> 
+#include <cctype> 
+ 
+#include <stdlib.h> 
+#include <sys/stat.h> 
+#include <sstream> 
+ 
+#include "thrift/platform.h" 
+#include "thrift/generate/t_oop_generator.h" 
+ 
+using std::map; 
+using std::ostream; 
+using std::ostringstream; 
+using std::string; 
+using std::stringstream; 
+using std::vector; 
+ 
+static const string endl = "\n"; // avoid ostream << std::endl flushes 
+ 
+struct member_mapping_scope { 
+  void* scope_member; 
+  std::map<std::string, std::string> mapping_table; 
+}; 
+ 
+class t_csharp_generator : public t_oop_generator { 
+public: 
+  t_csharp_generator(t_program* program, 
+                     const std::map<std::string, std::string>& parsed_options, 
+                     const std::string& option_string) 
+    : t_oop_generator(program) { 
+    (void)option_string; 
+ 
+    std::map<std::string, std::string>::const_iterator iter; 
+ 
+    async_ = false; 
+    nullable_ = false; 
+    hashcode_ = false; 
+    union_ = false; 
+    serialize_ = false; 
+    wcf_ = false; 
+    wcf_namespace_.clear(); 
+    for( iter = parsed_options.begin(); iter != parsed_options.end(); ++iter) { 
+      if( iter->first.compare("async") == 0) { 
+        async_ = true; 
+      } else if( iter->first.compare("nullable") == 0) { 
+        nullable_ = true; 
+      } else if( iter->first.compare("hashcode") == 0) { 
+        hashcode_ = true; 
+      } else if( iter->first.compare("union") == 0) { 
+        union_ = true; 
+      } else if( iter->first.compare("serial") == 0) { 
+        serialize_ = true; 
+        wcf_namespace_ = iter->second; // since there can be only one namespace 
+      } else if( iter->first.compare("wcf") == 0) { 
+        wcf_ = true; 
+        wcf_namespace_ = iter->second; 
+      } else { 
+        throw "unknown option csharp:" + iter->first; 
+      } 
+    } 
+ 
+    out_dir_base_ = "gen-csharp"; 
+  } 
+  void init_generator(); 
+  void close_generator(); 
+ 
+  void generate_consts(std::vector<t_const*> consts); 
+ 
+  void generate_typedef(t_typedef* ttypedef); 
+  void generate_enum(t_enum* tenum); 
+  void generate_struct(t_struct* tstruct); 
+  void generate_union(t_struct* tunion); 
+  void generate_xception(t_struct* txception); 
+  void generate_service(t_service* tservice); 
+  void generate_property(ostream& out, t_field* tfield, bool isPublic, bool generateIsset); 
+  void generate_csharp_property(ostream& out, 
+                                t_field* tfield, 
+                                bool isPublic, 
+                                bool includeIsset = true, 
+                                std::string fieldPrefix = ""); 
+  bool print_const_value(std::ostream& out, 
+                         std::string name, 
+                         t_type* type, 
+                         t_const_value* value, 
+                         bool in_static, 
+                         bool defval = false, 
+                         bool needtype = false); 
+  std::string render_const_value(std::ostream& out, 
+                                 std::string name, 
+                                 t_type* type, 
+                                 t_const_value* value); 
+  void print_const_constructor(std::ostream& out, std::vector<t_const*> consts); 
+  void print_const_def_value(std::ostream& out, 
+                             std::string name, 
+                             t_type* type, 
+                             t_const_value* value); 
+ 
+  void generate_csharp_struct(t_struct* tstruct, bool is_exception); 
+  void generate_csharp_union(t_struct* tunion); 
+  void generate_csharp_struct_definition(std::ostream& out, 
+                                         t_struct* tstruct, 
+                                         bool is_xception = false, 
+                                         bool in_class = false, 
+                                         bool is_result = false); 
+  void generate_csharp_union_definition(std::ostream& out, t_struct* tunion); 
+  void generate_csharp_union_class(std::ostream& out, t_struct* tunion, t_field* tfield); 
+  void generate_csharp_wcffault(std::ostream& out, t_struct* tstruct); 
+  void generate_csharp_struct_reader(std::ostream& out, t_struct* tstruct); 
+  void generate_csharp_struct_result_writer(std::ostream& out, t_struct* tstruct); 
+  void generate_csharp_struct_writer(std::ostream& out, t_struct* tstruct); 
+  void generate_csharp_struct_tostring(std::ostream& out, t_struct* tstruct); 
+  void generate_csharp_struct_equals(std::ostream& out, t_struct* tstruct); 
+  void generate_csharp_struct_hashcode(std::ostream& out, t_struct* tstruct); 
+  void generate_csharp_union_reader(std::ostream& out, t_struct* tunion); 
+ 
+  void generate_function_helpers(t_function* tfunction); 
+  void generate_service_interface(t_service* tservice); 
+  void generate_separate_service_interfaces(t_service* tservice); 
+  void generate_sync_service_interface(t_service* tservice); 
+  void generate_async_service_interface(t_service* tservice); 
+  void generate_combined_service_interface(t_service* tservice); 
+  void generate_silverlight_async_methods(t_service* tservice); 
+  void generate_service_helpers(t_service* tservice); 
+  void generate_service_client(t_service* tservice); 
+  void generate_service_server(t_service* tservice); 
+  void generate_service_server_sync(t_service* tservice); 
+  void generate_service_server_async(t_service* tservice); 
+  void generate_process_function(t_service* tservice, t_function* function); 
+  void generate_process_function_async(t_service* tservice, t_function* function); 
+ 
+  void generate_deserialize_field(std::ostream& out, 
+                                  t_field* tfield, 
+                                  std::string prefix = "", 
+                                  bool is_propertyless = false); 
+  void generate_deserialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = ""); 
+  void generate_deserialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+  void generate_deserialize_set_element(std::ostream& out, t_set* tset, std::string prefix = ""); 
+  void generate_deserialize_map_element(std::ostream& out, t_map* tmap, std::string prefix = ""); 
+  void generate_deserialize_list_element(std::ostream& out, t_list* list, std::string prefix = ""); 
+  void generate_serialize_field(std::ostream& out, 
+                                t_field* tfield, 
+                                std::string prefix = "", 
+                                bool is_element = false, 
+                                bool is_propertyless = false); 
+  void generate_serialize_struct(std::ostream& out, t_struct* tstruct, std::string prefix = ""); 
+  void generate_serialize_container(std::ostream& out, t_type* ttype, std::string prefix = ""); 
+  void generate_serialize_map_element(std::ostream& out, 
+                                      t_map* tmap, 
+                                      std::string iter, 
+                                      std::string map); 
+  void generate_serialize_set_element(std::ostream& out, t_set* tmap, std::string iter); 
+  void generate_serialize_list_element(std::ostream& out, t_list* tlist, std::string iter); 
+ 
+  void generate_csharp_doc(std::ostream& out, t_field* field); 
+  void generate_csharp_doc(std::ostream& out, t_doc* tdoc); 
+  void generate_csharp_doc(std::ostream& out, t_function* tdoc); 
+  void generate_csharp_docstring_comment(std::ostream& out, string contents); 
+ 
+  void start_csharp_namespace(std::ostream& out); 
+  void end_csharp_namespace(std::ostream& out); 
+ 
+  std::string csharp_type_usings(); 
+  std::string csharp_thrift_usings(); 
+ 
+  std::string type_name(t_type* ttype, 
+                        bool in_countainer = false, 
+                        bool in_init = false, 
+                        bool in_param = false, 
+                        bool is_required = false); 
+  std::string base_type_name(t_base_type* tbase, 
+                             bool in_container = false, 
+                             bool in_param = false, 
+                             bool is_required = false); 
+  std::string declare_field(t_field* tfield, bool init = false, std::string prefix = ""); 
+  std::string function_signature_async_begin(t_function* tfunction, std::string prefix = ""); 
+  std::string function_signature_async_end(t_function* tfunction, std::string prefix = ""); 
+  std::string function_signature_async(t_function* tfunction, std::string prefix = ""); 
+  std::string function_signature(t_function* tfunction, std::string prefix = ""); 
+  std::string argument_list(t_struct* tstruct); 
+  std::string type_to_enum(t_type* ttype); 
+  std::string prop_name(t_field* tfield, bool suppress_mapping = false); 
+  std::string get_enum_class_name(t_type* type); 
+ 
+  bool field_has_default(t_field* tfield) { return tfield->get_value() != NULL; } 
+ 
+  bool field_is_required(t_field* tfield) { return tfield->get_req() == t_field::T_REQUIRED; } 
+ 
+  bool type_can_be_null(t_type* ttype) { 
+    while (ttype->is_typedef()) { 
+      ttype = ((t_typedef*)ttype)->get_type(); 
+    } 
+ 
+    return ttype->is_container() || ttype->is_struct() || ttype->is_xception() 
+           || ttype->is_string(); 
+  } 
+ 
+private: 
+  std::string namespace_name_; 
+  ofstream_with_content_based_conditional_update f_service_; 
+  std::string namespace_dir_; 
+  bool async_; 
+  bool nullable_; 
+  bool union_; 
+  bool hashcode_; 
+  bool serialize_; 
+  bool wcf_; 
+  std::string wcf_namespace_; 
+ 
+  std::map<std::string, int> csharp_keywords; 
+  std::vector<member_mapping_scope>  member_mapping_scopes; 
+ 
+  void init_keywords(); 
+  std::string normalize_name(std::string name); 
+  std::string make_valid_csharp_identifier(std::string const& fromName); 
+  void prepare_member_name_mapping(t_struct* tstruct); 
+  void prepare_member_name_mapping(void* scope, 
+                                   const vector<t_field*>& members, 
+                                   const string& structname); 
+  void cleanup_member_name_mapping(void* scope); 
+  string get_mapped_member_name(string oldname); 
+}; 
+ 
+void t_csharp_generator::init_generator() { 
+  MKDIR(get_out_dir().c_str()); 
+  namespace_name_ = program_->get_namespace("csharp"); 
+ 
+  string dir = namespace_name_; 
+  string subdir = get_out_dir().c_str(); 
+  string::size_type loc; 
+ 
+  while ((loc = dir.find(".")) != string::npos) { 
+    subdir = subdir + "/" + dir.substr(0, loc); 
+    MKDIR(subdir.c_str()); 
+    dir = dir.substr(loc + 1); 
+  } 
+  if (dir.size() > 0) { 
+    subdir = subdir + "/" + dir; 
+    MKDIR(subdir.c_str()); 
+  } 
+ 
+  namespace_dir_ = subdir; 
+  init_keywords(); 
+ 
+  while( ! member_mapping_scopes.empty()) { 
+    cleanup_member_name_mapping( member_mapping_scopes.back().scope_member); 
+  } 
+ 
+  pverbose("C# options:\n"); 
+  pverbose("- async ...... %s\n", (async_ ? "ON" : "off")); 
+  pverbose("- nullable ... %s\n", (nullable_ ? "ON" : "off")); 
+  pverbose("- union ...... %s\n", (union_ ? "ON" : "off")); 
+  pverbose("- hashcode ... %s\n", (hashcode_ ? "ON" : "off")); 
+  pverbose("- serialize .. %s\n", (serialize_ ? "ON" : "off")); 
+  pverbose("- wcf ........ %s\n", (wcf_ ? "ON" : "off")); 
+} 
+ 
+std::string t_csharp_generator::normalize_name(std::string name) { 
+  string tmp(name); 
+  std::transform(tmp.begin(), tmp.end(), tmp.begin(), static_cast<int (*)(int)>(std::tolower)); 
+ 
+  // un-conflict keywords by prefixing with "@" 
+  if (csharp_keywords.find(tmp) != csharp_keywords.end()) { 
+    return "@" + name; 
+  } 
+ 
+  // no changes necessary 
+  return name; 
+} 
+ 
+void t_csharp_generator::init_keywords() { 
+  csharp_keywords.clear(); 
+ 
+  // C# keywords 
+  csharp_keywords["abstract"] = 1; 
+  csharp_keywords["as"] = 1; 
+  csharp_keywords["base"] = 1; 
+  csharp_keywords["bool"] = 1; 
+  csharp_keywords["break"] = 1; 
+  csharp_keywords["byte"] = 1; 
+  csharp_keywords["case"] = 1; 
+  csharp_keywords["catch"] = 1; 
+  csharp_keywords["char"] = 1; 
+  csharp_keywords["checked"] = 1; 
+  csharp_keywords["class"] = 1; 
+  csharp_keywords["const"] = 1; 
+  csharp_keywords["continue"] = 1; 
+  csharp_keywords["decimal"] = 1; 
+  csharp_keywords["default"] = 1; 
+  csharp_keywords["delegate"] = 1; 
+  csharp_keywords["do"] = 1; 
+  csharp_keywords["double"] = 1; 
+  csharp_keywords["else"] = 1; 
+  csharp_keywords["enum"] = 1; 
+  csharp_keywords["event"] = 1; 
+  csharp_keywords["explicit"] = 1; 
+  csharp_keywords["extern"] = 1; 
+  csharp_keywords["false"] = 1; 
+  csharp_keywords["finally"] = 1; 
+  csharp_keywords["fixed"] = 1; 
+  csharp_keywords["float"] = 1; 
+  csharp_keywords["for"] = 1; 
+  csharp_keywords["foreach"] = 1; 
+  csharp_keywords["goto"] = 1; 
+  csharp_keywords["if"] = 1; 
+  csharp_keywords["implicit"] = 1; 
+  csharp_keywords["in"] = 1; 
+  csharp_keywords["int"] = 1; 
+  csharp_keywords["interface"] = 1; 
+  csharp_keywords["internal"] = 1; 
+  csharp_keywords["is"] = 1; 
+  csharp_keywords["lock"] = 1; 
+  csharp_keywords["long"] = 1; 
+  csharp_keywords["namespace"] = 1; 
+  csharp_keywords["new"] = 1; 
+  csharp_keywords["null"] = 1; 
+  csharp_keywords["object"] = 1; 
+  csharp_keywords["operator"] = 1; 
+  csharp_keywords["out"] = 1; 
+  csharp_keywords["override"] = 1; 
+  csharp_keywords["params"] = 1; 
+  csharp_keywords["private"] = 1; 
+  csharp_keywords["protected"] = 1; 
+  csharp_keywords["public"] = 1; 
+  csharp_keywords["readonly"] = 1; 
+  csharp_keywords["ref"] = 1; 
+  csharp_keywords["return"] = 1; 
+  csharp_keywords["sbyte"] = 1; 
+  csharp_keywords["sealed"] = 1; 
+  csharp_keywords["short"] = 1; 
+  csharp_keywords["sizeof"] = 1; 
+  csharp_keywords["stackalloc"] = 1; 
+  csharp_keywords["static"] = 1; 
+  csharp_keywords["string"] = 1; 
+  csharp_keywords["struct"] = 1; 
+  csharp_keywords["switch"] = 1; 
+  csharp_keywords["this"] = 1; 
+  csharp_keywords["throw"] = 1; 
+  csharp_keywords["true"] = 1; 
+  csharp_keywords["try"] = 1; 
+  csharp_keywords["typeof"] = 1; 
+  csharp_keywords["uint"] = 1; 
+  csharp_keywords["ulong"] = 1; 
+  csharp_keywords["unchecked"] = 1; 
+  csharp_keywords["unsafe"] = 1; 
+  csharp_keywords["ushort"] = 1; 
+  csharp_keywords["using"] = 1; 
+  csharp_keywords["virtual"] = 1; 
+  csharp_keywords["void"] = 1; 
+  csharp_keywords["volatile"] = 1; 
+  csharp_keywords["while"] = 1; 
+ 
+  // C# contextual keywords 
+  csharp_keywords["add"] = 1; 
+  csharp_keywords["alias"] = 1; 
+  csharp_keywords["ascending"] = 1; 
+  csharp_keywords["async"] = 1; 
+  csharp_keywords["await"] = 1; 
+  csharp_keywords["descending"] = 1; 
+  csharp_keywords["dynamic"] = 1; 
+  csharp_keywords["from"] = 1; 
+  csharp_keywords["get"] = 1; 
+  csharp_keywords["global"] = 1; 
+  csharp_keywords["group"] = 1; 
+  csharp_keywords["into"] = 1; 
+  csharp_keywords["join"] = 1; 
+  csharp_keywords["let"] = 1; 
+  csharp_keywords["orderby"] = 1; 
+  csharp_keywords["partial"] = 1; 
+  csharp_keywords["remove"] = 1; 
+  csharp_keywords["select"] = 1; 
+  csharp_keywords["set"] = 1; 
+  csharp_keywords["value"] = 1; 
+  csharp_keywords["var"] = 1; 
+  csharp_keywords["where"] = 1; 
+  csharp_keywords["yield"] = 1; 
+} 
+ 
+void t_csharp_generator::start_csharp_namespace(ostream& out) { 
+  if (!namespace_name_.empty()) { 
+    out << "namespace " << namespace_name_ << "\n"; 
+    scope_up(out); 
+  } 
+} 
+ 
+void t_csharp_generator::end_csharp_namespace(ostream& out) { 
+  if (!namespace_name_.empty()) { 
+    scope_down(out); 
+  } 
+} 
+ 
+string t_csharp_generator::csharp_type_usings() { 
+  return string() + "using System;\n" + "using System.Collections;\n" 
+         + "using System.Collections.Generic;\n" + "using System.Text;\n" + "using System.IO;\n" 
+         + ((async_) ? "using System.Threading.Tasks;\n" : "") + "using Thrift;\n" 
+         + "using Thrift.Collections;\n" + ((serialize_ || wcf_) ? "#if !SILVERLIGHT\n" : "") 
+         + ((serialize_ || wcf_) ? "using System.Xml.Serialization;\n" : "") 
+         + ((serialize_ || wcf_) ? "#endif\n" : "") + (wcf_ ? "//using System.ServiceModel;\n" : "") 
+         + "using System.Runtime.Serialization;\n"; 
+} 
+ 
+string t_csharp_generator::csharp_thrift_usings() { 
+  return string() + "using Thrift.Protocol;\n" + "using Thrift.Transport;\n"; 
+} 
+ 
+void t_csharp_generator::close_generator() { 
+} 
+void t_csharp_generator::generate_typedef(t_typedef* ttypedef) { 
+  (void)ttypedef; 
+} 
+ 
+void t_csharp_generator::generate_enum(t_enum* tenum) { 
+  string f_enum_name = namespace_dir_ + "/" + (tenum->get_name()) + ".cs"; 
+  ofstream_with_content_based_conditional_update f_enum; 
+  f_enum.open(f_enum_name.c_str()); 
+ 
+  f_enum << autogen_comment() << endl; 
+ 
+  start_csharp_namespace(f_enum); 
+ 
+  generate_csharp_doc(f_enum, tenum); 
+ 
+  indent(f_enum) << "public enum " << tenum->get_name() << "\n"; 
+  scope_up(f_enum); 
+ 
+  vector<t_enum_value*> constants = tenum->get_constants(); 
+  vector<t_enum_value*>::iterator c_iter; 
+  for (c_iter = constants.begin(); c_iter != constants.end(); ++c_iter) { 
+    generate_csharp_doc(f_enum, *c_iter); 
+ 
+    int value = (*c_iter)->get_value(); 
+    indent(f_enum) << (*c_iter)->get_name() << " = " << value << "," << endl; 
+  } 
+ 
+  scope_down(f_enum); 
+ 
+  end_csharp_namespace(f_enum); 
+ 
+  f_enum.close(); 
+} 
+ 
+void t_csharp_generator::generate_consts(std::vector<t_const*> consts) { 
+  if (consts.empty()) { 
+    return; 
+  } 
+  string f_consts_name = namespace_dir_ + '/' + program_name_ + ".Constants.cs"; 
+  ofstream_with_content_based_conditional_update f_consts; 
+  f_consts.open(f_consts_name.c_str()); 
+ 
+  f_consts << autogen_comment() << csharp_type_usings() << endl; 
+ 
+  start_csharp_namespace(f_consts); 
+ 
+  indent(f_consts) << "public static class " << make_valid_csharp_identifier(program_name_) 
+                   << "Constants" << endl; 
+  scope_up(f_consts); 
+ 
+  vector<t_const*>::iterator c_iter; 
+  bool need_static_constructor = false; 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    generate_csharp_doc(f_consts, (*c_iter)); 
+    if (print_const_value(f_consts, 
+                          (*c_iter)->get_name(), 
+                          (*c_iter)->get_type(), 
+                          (*c_iter)->get_value(), 
+                          false)) { 
+      need_static_constructor = true; 
+    } 
+  } 
+ 
+  if (need_static_constructor) { 
+    print_const_constructor(f_consts, consts); 
+  } 
+ 
+  scope_down(f_consts); 
+  end_csharp_namespace(f_consts); 
+  f_consts.close(); 
+} 
+ 
+void t_csharp_generator::print_const_def_value(std::ostream& out, 
+                                               string name, 
+                                               t_type* type, 
+                                               t_const_value* value) { 
+  if (type->is_struct() || type->is_xception()) { 
+    const vector<t_field*>& fields = ((t_struct*)type)->get_members(); 
+    vector<t_field*>::const_iterator f_iter; 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    prepare_member_name_mapping((t_struct*)type); 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      t_field* field = NULL; 
+      for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+        if ((*f_iter)->get_name() == v_iter->first->get_string()) { 
+          field = (*f_iter); 
+        } 
+      } 
+      if (field == NULL) { 
+        throw "type error: " + type->get_name() + " has no field " + v_iter->first->get_string(); 
+      } 
+      t_type* field_type = field->get_type(); 
+      string val = render_const_value(out, name, field_type, v_iter->second); 
+      indent(out) << name << "." << prop_name(field) << " = " << val << ";" << endl; 
+    } 
+    cleanup_member_name_mapping((t_struct*)type); 
+  } else if (type->is_map()) { 
+    t_type* ktype = ((t_map*)type)->get_key_type(); 
+    t_type* vtype = ((t_map*)type)->get_val_type(); 
+    const map<t_const_value*, t_const_value*, t_const_value::value_compare>& val = value->get_map(); 
+    map<t_const_value*, t_const_value*, t_const_value::value_compare>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string key = render_const_value(out, name, ktype, v_iter->first); 
+      string val = render_const_value(out, name, vtype, v_iter->second); 
+      indent(out) << name << "[" << key << "]" 
+                  << " = " << val << ";" << endl; 
+    } 
+  } else if (type->is_list() || type->is_set()) { 
+    t_type* etype; 
+    if (type->is_list()) { 
+      etype = ((t_list*)type)->get_elem_type(); 
+    } else { 
+      etype = ((t_set*)type)->get_elem_type(); 
+    } 
+ 
+    const vector<t_const_value*>& val = value->get_list(); 
+    vector<t_const_value*>::const_iterator v_iter; 
+    for (v_iter = val.begin(); v_iter != val.end(); ++v_iter) { 
+      string val = render_const_value(out, name, etype, *v_iter); 
+      indent(out) << name << ".Add(" << val << ");" << endl; 
+    } 
+  } 
+} 
+ 
+void t_csharp_generator::print_const_constructor(std::ostream& out, std::vector<t_const*> consts) { 
+  indent(out) << "static " << make_valid_csharp_identifier(program_name_).c_str() << "Constants()" 
+              << endl; 
+  scope_up(out); 
+  vector<t_const*>::iterator c_iter; 
+  for (c_iter = consts.begin(); c_iter != consts.end(); ++c_iter) { 
+    string name = (*c_iter)->get_name(); 
+    t_type* type = (*c_iter)->get_type(); 
+    t_const_value* value = (*c_iter)->get_value(); 
+ 
+    print_const_def_value(out, name, type, value); 
+  } 
+  scope_down(out); 
+} 
+ 
+// it seems like all that methods that call this are using in_static to be the opposite of what it 
+// would imply 
+bool t_csharp_generator::print_const_value(std::ostream& out, 
+                                           string name, 
+                                           t_type* type, 
+                                           t_const_value* value, 
+                                           bool in_static, 
+                                           bool defval, 
+                                           bool needtype) { 
+  indent(out); 
+  bool need_static_construction = !in_static; 
+  while (type->is_typedef()) { 
+    type = ((t_typedef*)type)->get_type(); 
+  } 
+ 
+  if (!defval || needtype) { 
+    out << (in_static ? "" : type->is_base_type() ? "public const " : "public static ") 
+        << type_name(type) << " "; 
+  } 
+  if (type->is_base_type()) { 
+    string v2 = render_const_value(out, name, type, value); 
+    out << name << " = " << v2 << ";" << endl; 
+    need_static_construction = false; 
+  } else if (type->is_enum()) { 
+    out << name << " = " << type_name(type, false, true) << "." << value->get_identifier_name() 
+        << ";" << endl; 
+    need_static_construction = false; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    out << name << " = new " << type_name(type) << "();" << endl; 
+  } else if (type->is_map()) { 
+    out << name << " = new " << type_name(type, true, true) << "();" << endl; 
+  } else if (type->is_list() || type->is_set()) { 
+    out << name << " = new " << type_name(type) << "();" << endl; 
+  } 
+ 
+  if (defval && !type->is_base_type() && !type->is_enum()) { 
+    print_const_def_value(out, name, type, value); 
+  } 
+ 
+  return need_static_construction; 
+} 
+ 
+std::string t_csharp_generator::render_const_value(ostream& out, 
+                                                   string name, 
+                                                   t_type* type, 
+                                                   t_const_value* value) { 
+  (void)name; 
+  std::ostringstream render; 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_STRING: 
+      render << '"' << get_escaped_string(value) << '"'; 
+      break; 
+    case t_base_type::TYPE_BOOL: 
+      render << ((value->get_integer() > 0) ? "true" : "false"); 
+      break; 
+    case t_base_type::TYPE_I8: 
+    case t_base_type::TYPE_I16: 
+    case t_base_type::TYPE_I32: 
+    case t_base_type::TYPE_I64: 
+      render << value->get_integer(); 
+      break; 
+    case t_base_type::TYPE_DOUBLE: 
+      if (value->get_type() == t_const_value::CV_INTEGER) { 
+        render << value->get_integer(); 
+      } else { 
+        render << value->get_double(); 
+      } 
+      break; 
+    default: 
+      throw "compiler error: no const of base type " + t_base_type::t_base_name(tbase); 
+    } 
+  } else if (type->is_enum()) { 
+    render << type->get_name() << "." << value->get_identifier_name(); 
+  } else { 
+    string t = tmp("tmp"); 
+    print_const_value(out, t, type, value, true, true, true); 
+    render << t; 
+  } 
+ 
+  return render.str(); 
+} 
+ 
+void t_csharp_generator::generate_struct(t_struct* tstruct) { 
+  if (union_ && tstruct->is_union()) { 
+    generate_csharp_union(tstruct); 
+  } else { 
+    generate_csharp_struct(tstruct, false); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_xception(t_struct* txception) { 
+  generate_csharp_struct(txception, true); 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct(t_struct* tstruct, bool is_exception) { 
+  string f_struct_name = namespace_dir_ + "/" + (tstruct->get_name()) + ".cs"; 
+  ofstream_with_content_based_conditional_update f_struct; 
+ 
+  f_struct.open(f_struct_name.c_str()); 
+ 
+  f_struct << autogen_comment() << csharp_type_usings() << csharp_thrift_usings() << endl; 
+ 
+  generate_csharp_struct_definition(f_struct, tstruct, is_exception); 
+ 
+  f_struct.close(); 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct_definition(ostream& out, 
+                                                           t_struct* tstruct, 
+                                                           bool is_exception, 
+                                                           bool in_class, 
+                                                           bool is_result) { 
+ 
+  if (!in_class) { 
+    start_csharp_namespace(out); 
+  } 
+ 
+  out << endl; 
+ 
+  generate_csharp_doc(out, tstruct); 
+  prepare_member_name_mapping(tstruct); 
+ 
+  indent(out) << "#if !SILVERLIGHT" << endl; 
+  indent(out) << "[Serializable]" << endl; 
+  indent(out) << "#endif" << endl; 
+  if ((serialize_ || wcf_) && !is_exception) { 
+    indent(out) << "[DataContract(Namespace=\"" << wcf_namespace_ << "\")]" 
+                << endl; // do not make exception classes directly WCF serializable, we provide a 
+                         // separate "fault" for that 
+  } 
+  bool is_final = (tstruct->annotations_.find("final") != tstruct->annotations_.end()); 
+ 
+  indent(out) << "public " << (is_final ? "sealed " : "") << "partial class " 
+              << normalize_name(tstruct->get_name()) << " : "; 
+ 
+  if (is_exception) { 
+    out << "TException, "; 
+  } 
+  out << "TBase"; 
+ 
+  out << endl; 
+ 
+  scope_up(out); 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  // make private members with public Properties 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    // if the field is requied, then we use auto-properties 
+    if (!field_is_required((*m_iter)) && (!nullable_ || field_has_default((*m_iter)))) { 
+      indent(out) << "private " << declare_field(*m_iter, false, "_") << endl; 
+    } 
+  } 
+  out << endl; 
+ 
+  bool has_non_required_fields = false; 
+  bool has_non_required_default_value_fields = false; 
+  bool has_required_fields = false; 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    generate_csharp_doc(out, *m_iter); 
+    generate_property(out, *m_iter, true, true); 
+    bool is_required = field_is_required((*m_iter)); 
+    bool has_default = field_has_default((*m_iter)); 
+    if (is_required) { 
+      has_required_fields = true; 
+    } else { 
+      if (has_default) { 
+        has_non_required_default_value_fields = true; 
+      } 
+      has_non_required_fields = true; 
+    } 
+  } 
+ 
+  bool generate_isset = (nullable_ && has_non_required_default_value_fields) 
+                        || (!nullable_ && has_non_required_fields); 
+  if (generate_isset) { 
+    out << endl; 
+    if (serialize_ || wcf_) { 
+      out << indent() << "[XmlIgnore] // XmlSerializer" << endl << indent() 
+          << "[DataMember(Order = 1)]  // XmlObjectSerializer, DataContractJsonSerializer, etc." 
+          << endl; 
+    } 
+    out << indent() << "public Isset __isset;" << endl << indent() << "#if !SILVERLIGHT" << endl 
+        << indent() << "[Serializable]" << endl << indent() << "#endif" << endl; 
+    if (serialize_ || wcf_) { 
+      indent(out) << "[DataContract]" << endl; 
+    } 
+    indent(out) << "public struct Isset {" << endl; 
+    indent_up(); 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      bool is_required = field_is_required((*m_iter)); 
+      bool has_default = field_has_default((*m_iter)); 
+      // if it is required, don't need Isset for that variable 
+      // if it is not required, if it has a default value, we need to generate Isset 
+      // if we are not nullable, then we generate Isset 
+      if (!is_required && (!nullable_ || has_default)) { 
+        if (serialize_ || wcf_) { 
+          indent(out) << "[DataMember]" << endl; 
+        } 
+        indent(out) << "public bool " << normalize_name((*m_iter)->get_name()) << ";" << endl; 
+      } 
+    } 
+ 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+ 
+    if (generate_isset && (serialize_ || wcf_)) { 
+      indent(out) << "#region XmlSerializer support" << endl << endl; 
+ 
+      for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+        bool is_required = field_is_required((*m_iter)); 
+        bool has_default = field_has_default((*m_iter)); 
+        // if it is required, don't need Isset for that variable 
+        // if it is not required, if it has a default value, we need to generate Isset 
+        // if we are not nullable, then we generate Isset 
+        if (!is_required && (!nullable_ || has_default)) { 
+          indent(out) << "public bool ShouldSerialize" << prop_name((*m_iter)) << "()" << endl; 
+          indent(out) << "{" << endl; 
+          indent_up(); 
+          indent(out) << "return __isset." << normalize_name((*m_iter)->get_name()) << ";" << endl; 
+          indent_down(); 
+          indent(out) << "}" << endl << endl; 
+        } 
+      } 
+ 
+      indent(out) << "#endregion XmlSerializer support" << endl << endl; 
+    } 
+  } 
+ 
+  // We always want a default, no argument constructor for Reading 
+  indent(out) << "public " << normalize_name(tstruct->get_name()) << "() {" << endl; 
+  indent_up(); 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    t_type* t = (*m_iter)->get_type(); 
+    while (t->is_typedef()) { 
+      t = ((t_typedef*)t)->get_type(); 
+    } 
+    if ((*m_iter)->get_value() != NULL) { 
+      if (field_is_required((*m_iter))) { 
+        print_const_value(out, "this." + prop_name(*m_iter), t, (*m_iter)->get_value(), true, true); 
+      } else { 
+        print_const_value(out, 
+                          "this._" + (*m_iter)->get_name(), 
+                          t, 
+                          (*m_iter)->get_value(), 
+                          true, 
+                          true); 
+        // Optionals with defaults are marked set 
+        indent(out) << "this.__isset." << normalize_name((*m_iter)->get_name()) << " = true;" 
+                    << endl; 
+      } 
+    } 
+  } 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  if (has_required_fields) { 
+    indent(out) << "public " << tstruct->get_name() << "("; 
+    bool first = true; 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      if (field_is_required((*m_iter))) { 
+        if (first) { 
+          first = false; 
+        } else { 
+          out << ", "; 
+        } 
+        out << type_name((*m_iter)->get_type()) << " " << normalize_name((*m_iter)->get_name()); 
+      } 
+    } 
+    out << ") : this() {" << endl; 
+    indent_up(); 
+ 
+    for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+      if (field_is_required((*m_iter))) { 
+        indent(out) << "this." << prop_name((*m_iter)) << " = " << normalize_name((*m_iter)->get_name()) << ";" 
+                    << endl; 
+      } 
+    } 
+ 
+    indent_down(); 
+    indent(out) << "}" << endl << endl; 
+  } 
+ 
+  generate_csharp_struct_reader(out, tstruct); 
+  if (is_result) { 
+    generate_csharp_struct_result_writer(out, tstruct); 
+  } else { 
+    generate_csharp_struct_writer(out, tstruct); 
+  } 
+  if (hashcode_) { 
+    generate_csharp_struct_equals(out, tstruct); 
+    generate_csharp_struct_hashcode(out, tstruct); 
+  } 
+  generate_csharp_struct_tostring(out, tstruct); 
+  scope_down(out); 
+  out << endl; 
+ 
+  // generate a corresponding WCF fault to wrap the exception 
+  if ((serialize_ || wcf_) && is_exception) { 
+    generate_csharp_wcffault(out, tstruct); 
+  } 
+ 
+  cleanup_member_name_mapping(tstruct); 
+  if (!in_class) { 
+    end_csharp_namespace(out); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_csharp_wcffault(ostream& out, t_struct* tstruct) { 
+  out << endl; 
+  indent(out) << "#if !SILVERLIGHT" << endl; 
+  indent(out) << "[Serializable]" << endl; 
+  indent(out) << "#endif" << endl; 
+  indent(out) << "[DataContract]" << endl; 
+  bool is_final = (tstruct->annotations_.find("final") != tstruct->annotations_.end()); 
+ 
+  indent(out) << "public " << (is_final ? "sealed " : "") << "partial class " << tstruct->get_name() 
+              << "Fault" << endl; 
+ 
+  scope_up(out); 
+ 
+  const vector<t_field*>& members = tstruct->get_members(); 
+  vector<t_field*>::const_iterator m_iter; 
+ 
+  // make private members with public Properties 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    indent(out) << "private " << declare_field(*m_iter, false, "_") << endl; 
+  } 
+  out << endl; 
+ 
+  for (m_iter = members.begin(); m_iter != members.end(); ++m_iter) { 
+    generate_property(out, *m_iter, true, false); 
+  } 
+ 
+  scope_down(out); 
+  out << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct_reader(ostream& out, t_struct* tstruct) { 
+  indent(out) << "public void Read (TProtocol iprot)" << endl; 
+  scope_up(out); 
+ 
+  out << indent() << "iprot.IncrementRecursionDepth();" << endl; 
+  out << indent() << "try" << endl; 
+  scope_up(out); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  // Required variables aren't in __isset, so we need tmp vars to check them 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (field_is_required((*f_iter))) { 
+      indent(out) << "bool isset_" << (*f_iter)->get_name() << " = false;" << endl; 
+    } 
+  } 
+ 
+  indent(out) << "TField field;" << endl << indent() << "iprot.ReadStructBegin();" << endl; 
+ 
+  indent(out) << "while (true)" << endl; 
+  scope_up(out); 
+ 
+  indent(out) << "field = iprot.ReadFieldBegin();" << endl; 
+ 
+  indent(out) << "if (field.Type == TType.Stop) { " << endl; 
+  indent_up(); 
+  indent(out) << "break;" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+ 
+  indent(out) << "switch (field.ID)" << endl; 
+ 
+  scope_up(out); 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    bool is_required = field_is_required((*f_iter)); 
+    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl; 
+    indent_up(); 
+    indent(out) << "if (field.Type == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl; 
+    indent_up(); 
+ 
+    generate_deserialize_field(out, *f_iter); 
+    if (is_required) { 
+      indent(out) << "isset_" << (*f_iter)->get_name() << " = true;" << endl; 
+    } 
+ 
+    indent_down(); 
+    out << indent() << "} else { " << endl << indent() << "  TProtocolUtil.Skip(iprot, field.Type);" 
+        << endl << indent() << "}" << endl << indent() << "break;" << endl; 
+    indent_down(); 
+  } 
+ 
+  indent(out) << "default: " << endl; 
+  indent_up(); 
+  indent(out) << "TProtocolUtil.Skip(iprot, field.Type);" << endl; 
+  indent(out) << "break;" << endl; 
+  indent_down(); 
+ 
+  scope_down(out); 
+ 
+  indent(out) << "iprot.ReadFieldEnd();" << endl; 
+ 
+  scope_down(out); 
+ 
+  indent(out) << "iprot.ReadStructEnd();" << endl; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (field_is_required((*f_iter))) { 
+      indent(out) << "if (!isset_" << (*f_iter)->get_name() << ")" << endl; 
+      indent_up(); 
+      out << indent() 
+          << "throw new TProtocolException(TProtocolException.INVALID_DATA, " 
+          << "\"required field " << prop_name((*f_iter)) << " not set\");" 
+          << endl; 
+      indent_down(); 
+    } 
+  } 
+ 
+  scope_down(out); 
+  out << indent() << "finally" << endl; 
+  scope_up(out); 
+  out << indent() << "iprot.DecrementRecursionDepth();" << endl; 
+  scope_down(out); 
+ 
+  indent_down(); 
+ 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct_writer(ostream& out, t_struct* tstruct) { 
+  out << indent() << "public void Write(TProtocol oprot) {" << endl; 
+  indent_up(); 
+ 
+  out << indent() << "oprot.IncrementRecursionDepth();" << endl; 
+  out << indent() << "try" << endl; 
+  scope_up(out); 
+ 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_sorted_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  indent(out) << "TStruct struc = new TStruct(\"" << name << "\");" << endl; 
+  indent(out) << "oprot.WriteStructBegin(struc);" << endl; 
+ 
+  if (fields.size() > 0) { 
+    indent(out) << "TField field = new TField();" << endl; 
+    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+      bool is_required = field_is_required((*f_iter)); 
+      bool has_default = field_has_default((*f_iter)); 
+      bool null_allowed = type_can_be_null((*f_iter)->get_type()); 
+ 
+      if (is_required) 
+      { 
+        if (null_allowed) { 
+          indent(out) << "if (" << prop_name((*f_iter)) << " == null)" << endl; 
+          indent_up(); 
+          out << indent() 
+              << "throw new TProtocolException(TProtocolException.INVALID_DATA, " 
+              << "\"required field " << prop_name((*f_iter)) << " not set\");" 
+              << endl; 
+          indent_down(); 
+        } 
+      } 
+      else 
+      { 
+        if (nullable_ && !has_default) { 
+            indent(out) << "if (" << prop_name((*f_iter)) << " != null) {" << endl; 
+        } 
+        else if (null_allowed) { 
+          out << indent() 
+              << "if (" << prop_name((*f_iter)) << " != null && __isset." 
+              << normalize_name((*f_iter)->get_name()) << ") {" 
+              << endl; 
+        } 
+        else { 
+           indent(out) << "if (__isset." << normalize_name((*f_iter)->get_name()) << ") {" << endl; 
+        } 
+        indent_up(); 
+      } 
+      indent(out) << "field.Name = \"" << (*f_iter)->get_name() << "\";" << endl; 
+      indent(out) << "field.Type = " << type_to_enum((*f_iter)->get_type()) << ";" << endl; 
+      indent(out) << "field.ID = " << (*f_iter)->get_key() << ";" << endl; 
+      indent(out) << "oprot.WriteFieldBegin(field);" << endl; 
+ 
+      generate_serialize_field(out, *f_iter); 
+ 
+      indent(out) << "oprot.WriteFieldEnd();" << endl; 
+      if (!is_required) { 
+        indent_down(); 
+        indent(out) << "}" << endl; 
+      } 
+    } 
+  } 
+ 
+  indent(out) << "oprot.WriteFieldStop();" << endl; 
+  indent(out) << "oprot.WriteStructEnd();" << endl; 
+ 
+  scope_down(out); 
+  out << indent() << "finally" << endl; 
+  scope_up(out); 
+  out << indent() << "oprot.DecrementRecursionDepth();" << endl; 
+  scope_down(out); 
+ 
+  indent_down(); 
+ 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct_result_writer(ostream& out, t_struct* tstruct) { 
+  indent(out) << "public void Write(TProtocol oprot) {" << endl; 
+  indent_up(); 
+ 
+  out << indent() << "oprot.IncrementRecursionDepth();" << endl; 
+  out << indent() << "try" << endl; 
+  scope_up(out); 
+ 
+  string name = tstruct->get_name(); 
+  const vector<t_field*>& fields = tstruct->get_sorted_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  indent(out) << "TStruct struc = new TStruct(\"" << name << "\");" << endl; 
+  indent(out) << "oprot.WriteStructBegin(struc);" << endl; 
+ 
+  if (fields.size() > 0) { 
+    indent(out) << "TField field = new TField();" << endl; 
+    bool first = true; 
+    for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+      if (first) { 
+        first = false; 
+        out << endl << indent() << "if "; 
+      } else { 
+        out << " else if "; 
+      } 
+ 
+      if (nullable_) { 
+        out << "(this." << prop_name((*f_iter)) << " != null) {" << endl; 
+      } else { 
+        out << "(this.__isset." << normalize_name((*f_iter)->get_name()) << ") {" << endl; 
+      } 
+      indent_up(); 
+ 
+      bool null_allowed = !nullable_ && type_can_be_null((*f_iter)->get_type()); 
+      if (null_allowed) { 
+        indent(out) << "if (" << prop_name(*f_iter) << " != null) {" << endl; 
+        indent_up(); 
+      } 
+ 
+      indent(out) << "field.Name = \"" << prop_name(*f_iter) << "\";" << endl; 
+      indent(out) << "field.Type = " << type_to_enum((*f_iter)->get_type()) << ";" << endl; 
+      indent(out) << "field.ID = " << (*f_iter)->get_key() << ";" << endl; 
+      indent(out) << "oprot.WriteFieldBegin(field);" << endl; 
+ 
+      generate_serialize_field(out, *f_iter); 
+ 
+      indent(out) << "oprot.WriteFieldEnd();" << endl; 
+ 
+      if (null_allowed) { 
+        indent_down(); 
+        indent(out) << "}" << endl; 
+      } 
+ 
+      indent_down(); 
+      indent(out) << "}"; 
+    } 
+  } 
+ 
+  out << endl << indent() << "oprot.WriteFieldStop();" << endl << indent() 
+      << "oprot.WriteStructEnd();" << endl; 
+ 
+  scope_down(out); 
+  out << indent() << "finally" << endl; 
+  scope_up(out); 
+  out << indent() << "oprot.DecrementRecursionDepth();" << endl; 
+  scope_down(out); 
+ 
+  indent_down(); 
+ 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct_tostring(ostream& out, t_struct* tstruct) { 
+  indent(out) << "public override string ToString() {" << endl; 
+  indent_up(); 
+ 
+  indent(out) << "StringBuilder __sb = new StringBuilder(\"" << tstruct->get_name() << "(\");" 
+              << endl; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  bool useFirstFlag = false; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (!field_is_required((*f_iter))) { 
+      indent(out) << "bool __first = true;" << endl; 
+      useFirstFlag = true; 
+    } 
+    break; 
+  } 
+ 
+  bool had_required = false; // set to true after first required field has been processed 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    bool is_required = field_is_required((*f_iter)); 
+    bool has_default = field_has_default((*f_iter)); 
+    if (nullable_ && !has_default && !is_required) { 
+      indent(out) << "if (" << prop_name((*f_iter)) << " != null) {" << endl; 
+      indent_up(); 
+    } else if (!is_required) { 
+      bool null_allowed = type_can_be_null((*f_iter)->get_type()); 
+      if (null_allowed) { 
+        indent(out) << "if (" << prop_name((*f_iter)) << " != null && __isset." 
+                    << normalize_name((*f_iter)->get_name()) << ") {" << endl; 
+        indent_up(); 
+      } else { 
+        indent(out) << "if (__isset." << normalize_name((*f_iter)->get_name()) << ") {" << endl; 
+        indent_up(); 
+      } 
+    } 
+ 
+    if (useFirstFlag && (!had_required)) { 
+      indent(out) << "if(!__first) { __sb.Append(\", \"); }" << endl; 
+      if (!is_required) { 
+        indent(out) << "__first = false;" << endl; 
+      } 
+      indent(out) << "__sb.Append(\"" << prop_name((*f_iter)) << ": \");" << endl; 
+    } else { 
+      indent(out) << "__sb.Append(\", " << prop_name((*f_iter)) << ": \");" << endl; 
+    } 
+ 
+    t_type* ttype = (*f_iter)->get_type(); 
+    if (ttype->is_xception() || ttype->is_struct()) { 
+      indent(out) << "__sb.Append(" << prop_name((*f_iter)) 
+                  << "== null ? \"<null>\" : " << prop_name((*f_iter)) << ".ToString());" << endl; 
+    } else { 
+      indent(out) << "__sb.Append(" << prop_name((*f_iter)) << ");" << endl; 
+    } 
+ 
+    if (!is_required) { 
+      indent_down(); 
+      indent(out) << "}" << endl; 
+    } else { 
+      had_required = true; // now __first must be false, so we don't need to check it anymore 
+    } 
+  } 
+ 
+  indent(out) << "__sb.Append(\")\");" << endl; 
+  indent(out) << "return __sb.ToString();" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_union(t_struct* tunion) { 
+  string f_union_name = namespace_dir_ + "/" + (tunion->get_name()) + ".cs"; 
+  ofstream_with_content_based_conditional_update f_union; 
+ 
+  f_union.open(f_union_name.c_str()); 
+ 
+  f_union << autogen_comment() << csharp_type_usings() << csharp_thrift_usings() << endl; 
+ 
+  generate_csharp_union_definition(f_union, tunion); 
+ 
+  f_union.close(); 
+} 
+ 
+void t_csharp_generator::generate_csharp_union_definition(std::ostream& out, t_struct* tunion) { 
+  // Let's define the class first 
+  start_csharp_namespace(out); 
+ 
+  indent(out) << "public abstract partial class " << tunion->get_name() << " : TAbstractBase {" 
+              << endl; 
+ 
+  indent_up(); 
+ 
+  indent(out) << "public abstract void Write(TProtocol protocol);" << endl; 
+  indent(out) << "public readonly bool Isset;" << endl; 
+  indent(out) << "public abstract object Data { get; }" << endl; 
+ 
+  indent(out) << "protected " << tunion->get_name() << "(bool isset) {" << endl; 
+  indent_up(); 
+  indent(out) << "Isset = isset;" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  indent(out) << "public class ___undefined : " << tunion->get_name() << " {" << endl; 
+  indent_up(); 
+ 
+  indent(out) << "public override object Data { get { return null; } }" << endl; 
+ 
+  indent(out) << "public ___undefined() : base(false) {}" << endl << endl; 
+ 
+  indent(out) << "public override void Write(TProtocol protocol) {" << endl; 
+  indent_up(); 
+  indent(out) << "throw new TProtocolException( TProtocolException.INVALID_DATA, \"Cannot persist " 
+                 "an union type which is not set.\");" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  const vector<t_field*>& fields = tunion->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    generate_csharp_union_class(out, tunion, (*f_iter)); 
+  } 
+ 
+  generate_csharp_union_reader(out, tunion); 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+ 
+  end_csharp_namespace(out); 
+} 
+ 
+void t_csharp_generator::generate_csharp_union_class(std::ostream& out, 
+                                                     t_struct* tunion, 
+                                                     t_field* tfield) { 
+  indent(out) << "public class " << tfield->get_name() << " : " << tunion->get_name() << " {" 
+              << endl; 
+  indent_up(); 
+  indent(out) << "private " << type_name(tfield->get_type()) << " _data;" << endl; 
+  indent(out) << "public override object Data { get { return _data; } }" << endl; 
+  indent(out) << "public " << tfield->get_name() << "(" << type_name(tfield->get_type()) 
+              << " data) : base(true) {" << endl; 
+  indent_up(); 
+  indent(out) << "this._data = data;" << endl; 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+  indent(out) << "public override void Write(TProtocol oprot) {" << endl; 
+  indent_up(); 
+ 
+  out << indent() << "oprot.IncrementRecursionDepth();" << endl; 
+  out << indent() << "try" << endl; 
+  scope_up(out); 
+ 
+  indent(out) << "TStruct struc = new TStruct(\"" << tunion->get_name() << "\");" << endl; 
+  indent(out) << "oprot.WriteStructBegin(struc);" << endl; 
+ 
+  indent(out) << "TField field = new TField();" << endl; 
+  indent(out) << "field.Name = \"" << tfield->get_name() << "\";" << endl; 
+  indent(out) << "field.Type = " << type_to_enum(tfield->get_type()) << ";" << endl; 
+  indent(out) << "field.ID = " << tfield->get_key() << ";" << endl; 
+  indent(out) << "oprot.WriteFieldBegin(field);" << endl; 
+ 
+  generate_serialize_field(out, tfield, "_data", true, true); 
+ 
+  indent(out) << "oprot.WriteFieldEnd();" << endl; 
+  indent(out) << "oprot.WriteFieldStop();" << endl; 
+  indent(out) << "oprot.WriteStructEnd();" << endl; 
+  indent_down(); 
+ 
+  scope_down(out); 
+  out << indent() << "finally" << endl; 
+  scope_up(out); 
+  out << indent() << "oprot.DecrementRecursionDepth();" << endl; 
+  scope_down(out); 
+ 
+  indent(out) << "}" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct_equals(ostream& out, t_struct* tstruct) { 
+  indent(out) << "public override bool Equals(object that) {" << endl; 
+  indent_up(); 
+ 
+  indent(out) << "var other = that as " << type_name(tstruct) << ";" << endl; 
+  indent(out) << "if (other == null) return false;" << endl; 
+  indent(out) << "if (ReferenceEquals(this, other)) return true;" << endl; 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  bool first = true; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+      indent(out) << "return "; 
+      indent_up(); 
+    } else { 
+      out << endl; 
+      indent(out) << "&& "; 
+    } 
+    if (!field_is_required((*f_iter)) && !(nullable_ && !field_has_default((*f_iter)))) { 
+      out << "((__isset." << normalize_name((*f_iter)->get_name()) << " == other.__isset." 
+          << normalize_name((*f_iter)->get_name()) << ") && ((!__isset." 
+          << normalize_name((*f_iter)->get_name()) << ") || ("; 
+    } 
+    t_type* ttype = (*f_iter)->get_type(); 
+    if (ttype->is_container() || ttype->is_binary()) { 
+      out << "TCollections.Equals("; 
+    } else { 
+      out << "System.Object.Equals("; 
+    } 
+    out << prop_name((*f_iter)) << ", other." << prop_name((*f_iter)) << ")"; 
+    if (!field_is_required((*f_iter)) && !(nullable_ && !field_has_default((*f_iter)))) { 
+      out << ")))"; 
+    } 
+  } 
+  if (first) { 
+    indent(out) << "return true;" << endl; 
+  } else { 
+    out << ";" << endl; 
+    indent_down(); 
+  } 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_struct_hashcode(ostream& out, t_struct* tstruct) { 
+  indent(out) << "public override int GetHashCode() {" << endl; 
+  indent_up(); 
+ 
+  indent(out) << "int hashcode = 0;" << endl; 
+  indent(out) << "unchecked {" << endl; 
+  indent_up(); 
+ 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    t_type* ttype = (*f_iter)->get_type(); 
+    indent(out) << "hashcode = (hashcode * 397) ^ "; 
+    if (field_is_required((*f_iter))) { 
+      out << "("; 
+    } else if (nullable_) { 
+      out << "(" << prop_name((*f_iter)) << " == null ? 0 : "; 
+    } else { 
+      out << "(!__isset." << normalize_name((*f_iter)->get_name()) << " ? 0 : "; 
+    } 
+    if (ttype->is_container()) { 
+      out << "(TCollections.GetHashCode(" << prop_name((*f_iter)) << "))"; 
+    } else { 
+      out << "(" << prop_name((*f_iter)) << ".GetHashCode())"; 
+    } 
+    out << ");" << endl; 
+  } 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl; 
+  indent(out) << "return hashcode;" << endl; 
+ 
+  indent_down(); 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_service(t_service* tservice) { 
+  string f_service_name = namespace_dir_ + "/" + service_name_ + ".cs"; 
+  f_service_.open(f_service_name.c_str()); 
+ 
+  f_service_ << autogen_comment() << csharp_type_usings() << csharp_thrift_usings() << endl; 
+ 
+  start_csharp_namespace(f_service_); 
+ 
+  indent(f_service_) << "public partial class " << normalize_name(service_name_) << " {" << endl; 
+  indent_up(); 
+ 
+  generate_service_interface(tservice); 
+  generate_service_client(tservice); 
+  generate_service_server(tservice); 
+  generate_service_helpers(tservice); 
+ 
+  indent_down(); 
+ 
+  indent(f_service_) << "}" << endl; 
+  end_csharp_namespace(f_service_); 
+  f_service_.close(); 
+} 
+ 
+void t_csharp_generator::generate_service_interface(t_service* tservice) { 
+  generate_separate_service_interfaces(tservice); 
+} 
+ 
+void t_csharp_generator::generate_separate_service_interfaces(t_service* tservice) { 
+  generate_sync_service_interface(tservice); 
+ 
+  if (async_) { 
+    generate_async_service_interface(tservice); 
+  } 
+ 
+  generate_combined_service_interface(tservice); 
+} 
+ 
+void t_csharp_generator::generate_sync_service_interface(t_service* tservice) { 
+  string extends = ""; 
+  string extends_iface = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = type_name(tservice->get_extends()); 
+    extends_iface = " : " + extends + ".ISync"; 
+  } 
+ 
+  generate_csharp_doc(f_service_, tservice); 
+ 
+  if (wcf_) { 
+    indent(f_service_) << "[ServiceContract(Namespace=\"" << wcf_namespace_ << "\")]" << endl; 
+  } 
+  indent(f_service_) << "public interface ISync" << extends_iface << " {" << endl; 
+ 
+  indent_up(); 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_csharp_doc(f_service_, *f_iter); 
+ 
+    // if we're using WCF, add the corresponding attributes 
+    if (wcf_) { 
+      indent(f_service_) << "[OperationContract]" << endl; 
+ 
+      const std::vector<t_field*>& xceptions = (*f_iter)->get_xceptions()->get_members(); 
+      vector<t_field*>::const_iterator x_iter; 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+        indent(f_service_) << "[FaultContract(typeof(" 
+          + type_name((*x_iter)->get_type(), false, false) + "Fault))]" << endl; 
+      } 
+    } 
+ 
+    indent(f_service_) << function_signature(*f_iter) << ";" << endl; 
+  } 
+  indent_down(); 
+  f_service_ << indent() << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_async_service_interface(t_service* tservice) { 
+  string extends = ""; 
+  string extends_iface = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = type_name(tservice->get_extends()); 
+    extends_iface = " : " + extends + ".IAsync"; 
+  } 
+ 
+  generate_csharp_doc(f_service_, tservice); 
+ 
+  if (wcf_) { 
+    indent(f_service_) << "[ServiceContract(Namespace=\"" << wcf_namespace_ << "\")]" << endl; 
+  } 
+  indent(f_service_) << "public interface IAsync" << extends_iface << " {" << endl; 
+ 
+  indent_up(); 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_csharp_doc(f_service_, *f_iter); 
+ 
+    // if we're using WCF, add the corresponding attributes 
+    if (wcf_) { 
+      indent(f_service_) << "[OperationContract]" << endl; 
+ 
+      const std::vector<t_field*>& xceptions = (*f_iter)->get_xceptions()->get_members(); 
+      vector<t_field*>::const_iterator x_iter; 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+        indent(f_service_) << "[FaultContract(typeof(" 
+          + type_name((*x_iter)->get_type(), false, false) + "Fault))]" << endl; 
+      } 
+    } 
+ 
+    indent(f_service_) << function_signature_async(*f_iter) << ";" << endl; 
+  } 
+  indent_down(); 
+  f_service_ << indent() << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_combined_service_interface(t_service* tservice) { 
+  string extends_iface = " : ISync"; 
+ 
+  if (async_) { 
+    extends_iface += ", IAsync"; 
+  } 
+ 
+  generate_csharp_doc(f_service_, tservice); 
+ 
+  if (wcf_) { 
+    indent(f_service_) << "[ServiceContract(Namespace=\"" << wcf_namespace_ << "\")]" << endl; 
+  } 
+ 
+  indent(f_service_) << "public interface Iface" << extends_iface << " {" << endl; 
+ 
+  indent_up(); 
+ 
+  // We need to generate extra old style async methods for silverlight. Since 
+  // this isn't something you'd want to implement server-side, just put them into 
+  // the main Iface interface. 
+  generate_silverlight_async_methods(tservice); 
+ 
+  indent_down(); 
+ 
+  f_service_ << indent() << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_silverlight_async_methods(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_csharp_doc(f_service_, *f_iter); 
+ 
+    // For backwards compatibility, include the Begin_, End_ methods if we're generating 
+    // with the async flag. I'm not sure this is necessary, so someone with more knowledge 
+    // can maybe remove these checks if they know it's safe. 
+    if (!async_) { 
+      indent(f_service_) << "#if SILVERLIGHT" << endl; 
+    } 
+ 
+    indent(f_service_) << function_signature_async_begin(*f_iter, "Begin_") << ";" << endl; 
+    indent(f_service_) << function_signature_async_end(*f_iter, "End_") << ";" << endl; 
+ 
+    if (!async_) { 
+      indent(f_service_) << "#endif" << endl; 
+    } 
+  } 
+} 
+ 
+void t_csharp_generator::generate_service_helpers(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    t_struct* ts = (*f_iter)->get_arglist(); 
+    generate_csharp_struct_definition(f_service_, ts, false, true); 
+    generate_function_helpers(*f_iter); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_service_client(t_service* tservice) { 
+  string extends = ""; 
+  string extends_client = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = type_name(tservice->get_extends()); 
+    extends_client = extends + ".Client, "; 
+  } else { 
+    extends_client = "IDisposable, "; 
+  } 
+ 
+  generate_csharp_doc(f_service_, tservice); 
+ 
+  indent(f_service_) << "public class Client : " << extends_client << "Iface {" << endl; 
+  indent_up(); 
+  indent(f_service_) << "public Client(TProtocol prot) : this(prot, prot)" << endl; 
+  scope_up(f_service_); 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  indent(f_service_) << "public Client(TProtocol iprot, TProtocol oprot)"; 
+  if (!extends.empty()) { 
+    f_service_ << " : base(iprot, oprot)"; 
+  } 
+  f_service_ << endl; 
+ 
+  scope_up(f_service_); 
+  if (extends.empty()) { 
+    f_service_ << indent() << "iprot_ = iprot;" << endl << indent() << "oprot_ = oprot;" << endl; 
+  } 
+  scope_down(f_service_); 
+ 
+  f_service_ << endl; 
+ 
+  if (extends.empty()) { 
+    f_service_ << indent() << "protected TProtocol iprot_;" << endl << indent() 
+               << "protected TProtocol oprot_;" << endl << indent() << "protected int seqid_;" 
+               << endl << endl; 
+ 
+    f_service_ << indent() << "public TProtocol InputProtocol" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "get { return iprot_; }" << endl; 
+    scope_down(f_service_); 
+ 
+    f_service_ << indent() << "public TProtocol OutputProtocol" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "get { return oprot_; }" << endl; 
+    scope_down(f_service_); 
+    f_service_ << endl << endl; 
+ 
+    indent(f_service_) << "#region \" IDisposable Support \"" << endl; 
+    indent(f_service_) << "private bool _IsDisposed;" << endl << endl; 
+    indent(f_service_) << "// IDisposable" << endl; 
+    indent(f_service_) << "public void Dispose()" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "Dispose(true);" << endl; 
+    scope_down(f_service_); 
+    indent(f_service_) << endl << endl; 
+    indent(f_service_) << "protected virtual void Dispose(bool disposing)" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "if (!_IsDisposed)" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "if (disposing)" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "if (iprot_ != null)" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "((IDisposable)iprot_).Dispose();" << endl; 
+    scope_down(f_service_); 
+    indent(f_service_) << "if (oprot_ != null)" << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "((IDisposable)oprot_).Dispose();" << endl; 
+    scope_down(f_service_); 
+    scope_down(f_service_); 
+    scope_down(f_service_); 
+    indent(f_service_) << "_IsDisposed = true;" << endl; 
+    scope_down(f_service_); 
+    indent(f_service_) << "#endregion" << endl; 
+    f_service_ << endl << endl; 
+  } 
+ 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::const_iterator f_iter; 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    string funname = (*f_iter)->get_name(); 
+ 
+    indent(f_service_) << endl; 
+ 
+    if (!async_) { 
+      indent(f_service_) << "#if SILVERLIGHT" << endl; 
+    } 
+    // Begin_ 
+    indent(f_service_) << "public " << function_signature_async_begin(*f_iter, "Begin_") << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "return " 
+                       << "send_" << funname << "(callback, state"; 
+ 
+    t_struct* arg_struct = (*f_iter)->get_arglist(); 
+    prepare_member_name_mapping(arg_struct); 
+ 
+    const vector<t_field*>& fields = arg_struct->get_members(); 
+    vector<t_field*>::const_iterator fld_iter; 
+    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+      f_service_ << ", "; 
+      f_service_ << normalize_name((*fld_iter)->get_name()); 
+    } 
+    f_service_ << ");" << endl; 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+ 
+    // End 
+    indent(f_service_) << "public " << function_signature_async_end(*f_iter, "End_") << endl; 
+    scope_up(f_service_); 
+    indent(f_service_) << "oprot_.Transport.EndFlush(asyncResult);" << endl; 
+    if (!(*f_iter)->is_oneway()) { 
+      f_service_ << indent(); 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        f_service_ << "return "; 
+      } 
+      f_service_ << "recv_" << funname << "();" << endl; 
+    } 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+ 
+    // async 
+    bool first; 
+    if (async_) { 
+      indent(f_service_) << "public async " << function_signature_async(*f_iter, "") << endl; 
+      scope_up(f_service_); 
+ 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        indent(f_service_) << type_name((*f_iter)->get_returntype()) << " retval;" << endl; 
+        indent(f_service_) << "retval = "; 
+      } else { 
+        indent(f_service_); 
+      } 
+      f_service_ << "await Task.Run(() =>" << endl; 
+      scope_up(f_service_); 
+      indent(f_service_); 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        f_service_ << "return "; 
+      } 
+      f_service_ << funname << "("; 
+      first = true; 
+      for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+        if (first) { 
+          first = false; 
+        } else { 
+          f_service_ << ", "; 
+        } 
+        f_service_ << (*fld_iter)->get_name(); 
+      } 
+      f_service_ << ");" << endl; 
+      indent_down(); 
+      indent(f_service_) << "});" << endl; 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        indent(f_service_) << "return retval;" << endl; 
+      } 
+      scope_down(f_service_); 
+      f_service_ << endl; 
+    } 
+ 
+    if (!async_) { 
+      indent(f_service_) << "#endif" << endl << endl; 
+    } 
+ 
+    // "Normal" Synchronous invoke 
+    generate_csharp_doc(f_service_, *f_iter); 
+    indent(f_service_) << "public " << function_signature(*f_iter) << endl; 
+    scope_up(f_service_); 
+ 
+    if (!async_) { 
+      indent(f_service_) << "#if !SILVERLIGHT" << endl; 
+      indent(f_service_) << "send_" << funname << "("; 
+ 
+      first = true; 
+      for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+        if (first) { 
+          first = false; 
+        } else { 
+          f_service_ << ", "; 
+        } 
+        f_service_ << normalize_name((*fld_iter)->get_name()); 
+      } 
+      f_service_ << ");" << endl; 
+ 
+      if (!(*f_iter)->is_oneway()) { 
+        f_service_ << indent(); 
+        if (!(*f_iter)->get_returntype()->is_void()) { 
+          f_service_ << "return "; 
+        } 
+        f_service_ << "recv_" << funname << "();" << endl; 
+      } 
+      f_service_ << endl; 
+ 
+      indent(f_service_) << "#else" << endl; 
+    } 
+ 
+    // Silverlight synchronous invoke 
+    indent(f_service_) << "var asyncResult = Begin_" << funname << "(null, null"; 
+    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+      f_service_ << ", " << normalize_name((*fld_iter)->get_name()); 
+    } 
+    f_service_ << ");" << endl; 
+ 
+    if (!(*f_iter)->is_oneway()) { 
+      f_service_ << indent(); 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        f_service_ << "return "; 
+      } 
+      f_service_ << "End_" << funname << "(asyncResult);" << endl; 
+    } 
+    f_service_ << endl; 
+ 
+    if (!async_) { 
+      indent(f_service_) << "#endif" << endl; 
+    } 
+    scope_down(f_service_); 
+ 
+    // Send 
+    t_function send_function(g_type_void, 
+                             string("send_") + (*f_iter)->get_name(), 
+                             (*f_iter)->get_arglist()); 
+ 
+    string argsname = (*f_iter)->get_name() + "_args"; 
+ 
+    if (!async_) { 
+      indent(f_service_) << "#if SILVERLIGHT" << endl; 
+    } 
+    indent(f_service_) << "public " << function_signature_async_begin(&send_function) << endl; 
+    if (!async_) { 
+      indent(f_service_) << "#else" << endl; 
+      indent(f_service_) << "public " << function_signature(&send_function) << endl; 
+      indent(f_service_) << "#endif" << endl; 
+    } 
+    scope_up(f_service_); 
+ 
+    f_service_ << indent() << "oprot_.WriteMessageBegin(new TMessage(\"" << funname << "\", " 
+               << ((*f_iter)->is_oneway() ? "TMessageType.Oneway" : "TMessageType.Call") 
+               << ", seqid_));" << endl << indent() << argsname << " args = new " << argsname 
+               << "();" << endl; 
+ 
+    for (fld_iter = fields.begin(); fld_iter != fields.end(); ++fld_iter) { 
+      f_service_ << indent() << "args." << prop_name(*fld_iter) << " = " 
+                 << normalize_name((*fld_iter)->get_name()) << ";" << endl; 
+    } 
+ 
+    f_service_ << indent() << "args.Write(oprot_);" << endl << indent() 
+               << "oprot_.WriteMessageEnd();" << endl; 
+    ; 
+ 
+    if (!async_) { 
+      indent(f_service_) << "#if SILVERLIGHT" << endl; 
+    } 
+    indent(f_service_) << "return oprot_.Transport.BeginFlush(callback, state);" << endl; 
+    if (!async_) { 
+      indent(f_service_) << "#else" << endl; 
+      indent(f_service_) << "oprot_.Transport.Flush();" << endl; 
+      indent(f_service_) << "#endif" << endl; 
+    } 
+ 
+    cleanup_member_name_mapping(arg_struct); 
+    scope_down(f_service_); 
+    f_service_ << endl; 
+ 
+    if (!(*f_iter)->is_oneway()) { 
+      string resultname = (*f_iter)->get_name() + "_result"; 
+ 
+      t_struct noargs(program_); 
+      t_function recv_function((*f_iter)->get_returntype(), 
+                               string("recv_") + (*f_iter)->get_name(), 
+                               &noargs, 
+                               (*f_iter)->get_xceptions()); 
+      indent(f_service_) << "public " << function_signature(&recv_function) << endl; 
+      scope_up(f_service_); 
+ 
+      t_struct* xs = (*f_iter)->get_xceptions(); 
+      prepare_member_name_mapping(xs, xs->get_members(), resultname); 
+ 
+      f_service_ << indent() << "TMessage msg = iprot_.ReadMessageBegin();" << endl << indent() 
+                 << "if (msg.Type == TMessageType.Exception) {" << endl; 
+      indent_up(); 
+      f_service_ << indent() << "TApplicationException x = TApplicationException.Read(iprot_);" 
+                 << endl << indent() << "iprot_.ReadMessageEnd();" << endl << indent() << "throw x;" 
+                 << endl; 
+      indent_down(); 
+      f_service_ << indent() << "}" << endl << indent() << resultname << " result = new " 
+                 << resultname << "();" << endl << indent() << "result.Read(iprot_);" << endl 
+                 << indent() << "iprot_.ReadMessageEnd();" << endl; 
+ 
+      if (!(*f_iter)->get_returntype()->is_void()) { 
+        if (nullable_) { 
+          if (type_can_be_null((*f_iter)->get_returntype())) { 
+            f_service_ << indent() << "if (result.Success != null) {" << endl << indent() 
+                       << "  return result.Success;" << endl << indent() << "}" << endl; 
+          } else { 
+            f_service_ << indent() << "if (result.Success.HasValue) {" << endl << indent() 
+                       << "  return result.Success.Value;" << endl << indent() << "}" << endl; 
+          } 
+        } else { 
+          f_service_ << indent() << "if (result.__isset.success) {" << endl << indent() 
+                     << "  return result.Success;" << endl << indent() << "}" << endl; 
+        } 
+      } 
+ 
+      const std::vector<t_field*>& xceptions = xs->get_members(); 
+      vector<t_field*>::const_iterator x_iter; 
+      for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+        if (nullable_) { 
+          f_service_ << indent() << "if (result." << prop_name(*x_iter) << " != null) {" << endl 
+                     << indent() << "  throw result." << prop_name(*x_iter) << ";" << endl 
+                     << indent() << "}" << endl; 
+        } else { 
+          f_service_ << indent() << "if (result.__isset." << normalize_name((*x_iter)->get_name()) 
+                     << ") {" << endl << indent() << "  throw result." << prop_name(*x_iter) << ";" 
+                     << endl << indent() << "}" << endl; 
+        } 
+      } 
+ 
+      if ((*f_iter)->get_returntype()->is_void()) { 
+        indent(f_service_) << "return;" << endl; 
+      } else { 
+        f_service_ << indent() 
+                   << "throw new " 
+                      "TApplicationException(TApplicationException.ExceptionType.MissingResult, \"" 
+                   << (*f_iter)->get_name() << " failed: unknown result\");" << endl; 
+      } 
+ 
+      cleanup_member_name_mapping((*f_iter)->get_xceptions()); 
+      scope_down(f_service_); 
+      f_service_ << endl; 
+    } 
+  } 
+ 
+  indent_down(); 
+  indent(f_service_) << "}" << endl; 
+} 
+ 
+void t_csharp_generator::generate_service_server(t_service* tservice) { 
+  if (async_) { 
+    generate_service_server_async(tservice); 
+    generate_service_server_sync(tservice); 
+  } 
+  else { 
+    generate_service_server_sync(tservice); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_service_server_sync(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+ 
+  string extends = ""; 
+  string extends_processor = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = type_name(tservice->get_extends()); 
+    extends_processor = extends + ".Processor, "; 
+  } 
+ 
+  indent(f_service_) << "public class Processor : " << extends_processor << "TProcessor {" << endl; 
+  indent_up(); 
+ 
+  indent(f_service_) << "public Processor(ISync iface)"; 
+ 
+  if (!extends.empty()) { 
+    f_service_ << " : base(iface)"; 
+  } 
+  f_service_ << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "iface_ = iface;" << endl; 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    f_service_ << indent() << "processMap_[\"" << (*f_iter)->get_name() 
+      << "\"] = " << (*f_iter)->get_name() << "_Process;" << endl; 
+  } 
+ 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  if (extends.empty()) { 
+    f_service_ 
+      << indent() 
+      << "protected delegate void ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);" 
+      << endl; 
+  } 
+ 
+  f_service_ << indent() << "private ISync iface_;" << endl; 
+ 
+  if (extends.empty()) { 
+    f_service_ << indent() << "protected Dictionary<string, ProcessFunction> processMap_ = new " 
+      "Dictionary<string, ProcessFunction>();" << endl; 
+  } 
+ 
+  f_service_ << endl; 
+ 
+  if (extends.empty()) { 
+    indent(f_service_) << "public bool Process(TProtocol iprot, TProtocol oprot)" << endl; 
+  } 
+  else { 
+    indent(f_service_) << "public new bool Process(TProtocol iprot, TProtocol oprot)" << endl; 
+  } 
+  scope_up(f_service_); 
+ 
+  f_service_ << indent() << "try" << endl; 
+  scope_up(f_service_); 
+ 
+  f_service_ << indent() << "TMessage msg = iprot.ReadMessageBegin();" << endl; 
+ 
+  f_service_ 
+    << indent() << "ProcessFunction fn;" << endl << indent() 
+    << "processMap_.TryGetValue(msg.Name, out fn);" << endl << indent() << "if (fn == null) {" 
+    << endl << indent() << "  TProtocolUtil.Skip(iprot, TType.Struct);" << endl << indent() 
+    << "  iprot.ReadMessageEnd();" << endl << indent() 
+    << "  TApplicationException x = new TApplicationException " 
+    "(TApplicationException.ExceptionType.UnknownMethod, \"Invalid method name: '\" + " 
+    "msg.Name + \"'\");" << endl << indent() 
+    << "  oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));" 
+    << endl << indent() << "  x.Write(oprot);" << endl << indent() << "  oprot.WriteMessageEnd();" 
+    << endl << indent() << "  oprot.Transport.Flush();" << endl << indent() << "  return true;" 
+    << endl << indent() << "}" << endl << indent() << "fn(msg.SeqID, iprot, oprot);" << endl; 
+ 
+  scope_down(f_service_); 
+ 
+  f_service_ << indent() << "catch (IOException)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "return false;" << endl; 
+  scope_down(f_service_); 
+ 
+  f_service_ << indent() << "return true;" << endl; 
+ 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_process_function(tservice, *f_iter); 
+  } 
+ 
+  indent_down(); 
+  indent(f_service_) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_service_server_async(t_service* tservice) { 
+  vector<t_function*> functions = tservice->get_functions(); 
+  vector<t_function*>::iterator f_iter; 
+ 
+  string extends = ""; 
+  string extends_processor = ""; 
+  if (tservice->get_extends() != NULL) { 
+    extends = type_name(tservice->get_extends()); 
+    extends_processor = extends + ".Processor, "; 
+  } 
+ 
+  indent(f_service_) << "public class AsyncProcessor : " << extends_processor << "TAsyncProcessor {" << endl; 
+  indent_up(); 
+ 
+  indent(f_service_) << "public AsyncProcessor(IAsync iface)"; 
+  if (!extends.empty()) { 
+    f_service_ << " : base(iface)"; 
+  } 
+  f_service_ << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "iface_ = iface;" << endl; 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    f_service_ << indent() << "processMap_[\"" << (*f_iter)->get_name() 
+      << "\"] = " << (*f_iter)->get_name() << "_ProcessAsync;" << endl; 
+  } 
+ 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  if (extends.empty()) { 
+    f_service_ 
+      << indent() 
+      << "protected delegate Task ProcessFunction(int seqid, TProtocol iprot, TProtocol oprot);" 
+      << endl; 
+  } 
+ 
+  f_service_ << indent() << "private IAsync iface_;" << endl; 
+ 
+  if (extends.empty()) { 
+    f_service_ << indent() << "protected Dictionary<string, ProcessFunction> processMap_ = new " 
+      "Dictionary<string, ProcessFunction>();" << endl; 
+  } 
+ 
+  f_service_ << endl; 
+ 
+  if (extends.empty()) { 
+    indent(f_service_) << "public async Task<bool> ProcessAsync(TProtocol iprot, TProtocol oprot)" << endl; 
+  } 
+  else { 
+    indent(f_service_) << "public new async Task<bool> ProcessAsync(TProtocol iprot, TProtocol oprot)" << endl; 
+  } 
+  scope_up(f_service_); 
+ 
+  f_service_ << indent() << "try" << endl; 
+  scope_up(f_service_); 
+ 
+  f_service_ << indent() << "TMessage msg = iprot.ReadMessageBegin();" << endl; 
+ 
+  f_service_ 
+    << indent() << "ProcessFunction fn;" << endl << indent() 
+    << "processMap_.TryGetValue(msg.Name, out fn);" << endl << indent() << "if (fn == null) {" 
+    << endl << indent() << "  TProtocolUtil.Skip(iprot, TType.Struct);" << endl << indent() 
+    << "  iprot.ReadMessageEnd();" << endl << indent() 
+    << "  TApplicationException x = new TApplicationException " 
+    "(TApplicationException.ExceptionType.UnknownMethod, \"Invalid method name: '\" + " 
+    "msg.Name + \"'\");" << endl << indent() 
+    << "  oprot.WriteMessageBegin(new TMessage(msg.Name, TMessageType.Exception, msg.SeqID));" 
+    << endl << indent() << "  x.Write(oprot);" << endl << indent() << "  oprot.WriteMessageEnd();" 
+    << endl << indent() << "  oprot.Transport.Flush();" << endl << indent() << "  return true;" 
+    << endl << indent() << "}" << endl << indent() << "await fn(msg.SeqID, iprot, oprot);" << endl; 
+ 
+  scope_down(f_service_); 
+ 
+  f_service_ << indent() << "catch (IOException)" << endl; 
+  scope_up(f_service_); 
+  f_service_ << indent() << "return false;" << endl; 
+  scope_down(f_service_); 
+ 
+  f_service_ << indent() << "return true;" << endl; 
+ 
+  scope_down(f_service_); 
+  f_service_ << endl; 
+ 
+  for (f_iter = functions.begin(); f_iter != functions.end(); ++f_iter) { 
+    generate_process_function_async(tservice, *f_iter); 
+  } 
+ 
+  indent_down(); 
+  indent(f_service_) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_function_helpers(t_function* tfunction) { 
+  if (tfunction->is_oneway()) { 
+    return; 
+  } 
+ 
+  t_struct result(program_, tfunction->get_name() + "_result"); 
+  t_field success(tfunction->get_returntype(), "success", 0); 
+  if (!tfunction->get_returntype()->is_void()) { 
+    result.append(&success); 
+  } 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const vector<t_field*>& fields = xs->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    result.append(*f_iter); 
+  } 
+ 
+  generate_csharp_struct_definition(f_service_, &result, false, true, true); 
+} 
+ 
+void t_csharp_generator::generate_process_function(t_service* tservice, t_function* tfunction) { 
+  (void)tservice; 
+  indent(f_service_) << "public void " << tfunction->get_name() 
+                     << "_Process(int seqid, TProtocol iprot, TProtocol oprot)" << endl; 
+  scope_up(f_service_); 
+ 
+  string argsname = tfunction->get_name() + "_args"; 
+  string resultname = tfunction->get_name() + "_result"; 
+ 
+  f_service_ << indent() << argsname << " args = new " << argsname << "();" << endl 
+             << indent() << "args.Read(iprot);" << endl 
+             << indent() << "iprot.ReadMessageEnd();" << endl; 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const std::vector<t_field*>& xceptions = xs->get_members(); 
+  vector<t_field*>::const_iterator x_iter; 
+ 
+  if (!tfunction->is_oneway()) { 
+    f_service_ << indent() << resultname << " result = new " << resultname << "();" << endl; 
+  } 
+ 
+  f_service_ << indent() << "try" << endl 
+             << indent() << "{" << endl; 
+  indent_up(); 
+ 
+  if (xceptions.size() > 0) { 
+    f_service_ << indent() << "try" << endl 
+               << indent() << "{" << endl; 
+    indent_up(); 
+  } 
+ 
+  t_struct* arg_struct = tfunction->get_arglist(); 
+  const std::vector<t_field*>& fields = arg_struct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  f_service_ << indent(); 
+  if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) { 
+    f_service_ << "result.Success = "; 
+  } 
+  f_service_ << "iface_." << normalize_name(tfunction->get_name()) << "("; 
+  bool first = true; 
+  prepare_member_name_mapping(arg_struct); 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      f_service_ << ", "; 
+    } 
+    f_service_ << "args." << prop_name(*f_iter); 
+    if (nullable_ && !type_can_be_null((*f_iter)->get_type())) { 
+      f_service_ << ".Value"; 
+    } 
+  } 
+  cleanup_member_name_mapping(arg_struct); 
+  f_service_ << ");" << endl; 
+ 
+  prepare_member_name_mapping(xs, xs->get_members(), resultname); 
+  if (xceptions.size() > 0) { 
+    indent_down(); 
+    f_service_ << indent() << "}" << endl; 
+    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+      f_service_ << indent() << "catch (" << type_name((*x_iter)->get_type(), false, false) << " " 
+                 << (*x_iter)->get_name() << ")" << endl 
+                 << indent() << "{" << endl; 
+      if (!tfunction->is_oneway()) { 
+        indent_up(); 
+        f_service_ << indent() << "result." << prop_name(*x_iter) << " = " << (*x_iter)->get_name() 
+                   << ";" << endl; 
+        indent_down(); 
+      } 
+      f_service_ << indent() << "}" << endl; 
+    } 
+  } 
+  if (!tfunction->is_oneway()) { 
+    f_service_ << indent() << "oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name() 
+               << "\", TMessageType.Reply, seqid)); " << endl; 
+    f_service_ << indent() << "result.Write(oprot);" << endl; 
+  } 
+  indent_down(); 
+ 
+  cleanup_member_name_mapping(xs); 
+ 
+  f_service_ << indent() << "}" << endl 
+             << indent() << "catch (TTransportException)" << endl 
+             << indent() << "{" << endl 
+             << indent() << "  throw;" << endl 
+             << indent() << "}" << endl 
+             << indent() << "catch (Exception ex)" << endl 
+             << indent() << "{" << endl 
+             << indent() << "  Console.Error.WriteLine(\"Error occurred in processor:\");" << endl 
+             << indent() << "  Console.Error.WriteLine(ex.ToString());" << endl; 
+ 
+  if (tfunction->is_oneway()) { 
+    f_service_ << indent() << "}" << endl; 
+  } else { 
+    f_service_ << indent() << "  TApplicationException x = new TApplicationException" << indent() 
+               << "(TApplicationException.ExceptionType.InternalError,\" Internal error.\");" 
+               << endl 
+               << indent() << "  oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name() 
+               << "\", TMessageType.Exception, seqid));" << endl 
+               << indent() << "  x.Write(oprot);" << endl 
+               << indent() << "}" << endl; 
+    f_service_ << indent() << "oprot.WriteMessageEnd();" << endl 
+               << indent() << "oprot.Transport.Flush();" << endl; 
+  } 
+ 
+  scope_down(f_service_); 
+ 
+  f_service_ << endl; 
+} 
+ 
+void t_csharp_generator::generate_process_function_async(t_service* tservice, t_function* tfunction) { 
+  (void)tservice; 
+  indent(f_service_) << "public async Task " << tfunction->get_name() 
+    << "_ProcessAsync(int seqid, TProtocol iprot, TProtocol oprot)" << endl; 
+  scope_up(f_service_); 
+ 
+  string argsname = tfunction->get_name() + "_args"; 
+  string resultname = tfunction->get_name() + "_result"; 
+ 
+  f_service_ << indent() << argsname << " args = new " << argsname << "();" << endl 
+    << indent() << "args.Read(iprot);" << endl 
+    << indent() << "iprot.ReadMessageEnd();" << endl; 
+ 
+  t_struct* xs = tfunction->get_xceptions(); 
+  const std::vector<t_field*>& xceptions = xs->get_members(); 
+  vector<t_field*>::const_iterator x_iter; 
+ 
+  if (!tfunction->is_oneway()) { 
+    f_service_ << indent() << resultname << " result = new " << resultname << "();" << endl; 
+  } 
+ 
+  f_service_ << indent() << "try" << endl 
+    << indent() << "{" << endl; 
+  indent_up(); 
+ 
+  if (xceptions.size() > 0) { 
+    f_service_ << indent() << "try" << endl 
+      << indent() << "{" << endl; 
+    indent_up(); 
+  } 
+ 
+  t_struct* arg_struct = tfunction->get_arglist(); 
+  const std::vector<t_field*>& fields = arg_struct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  f_service_ << indent(); 
+  if (!tfunction->is_oneway() && !tfunction->get_returntype()->is_void()) { 
+    f_service_ << "result.Success = "; 
+  } 
+  f_service_ << "await iface_." << normalize_name(tfunction->get_name()) << "Async("; 
+  bool first = true; 
+  prepare_member_name_mapping(arg_struct); 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } 
+    else { 
+      f_service_ << ", "; 
+    } 
+    f_service_ << "args." << prop_name(*f_iter); 
+    if (nullable_ && !type_can_be_null((*f_iter)->get_type())) { 
+      f_service_ << ".Value"; 
+    } 
+  } 
+  cleanup_member_name_mapping(arg_struct); 
+  f_service_ << ");" << endl; 
+ 
+  prepare_member_name_mapping(xs, xs->get_members(), resultname); 
+  if (xceptions.size() > 0) { 
+    indent_down(); 
+    f_service_ << indent() << "}" << endl; 
+    for (x_iter = xceptions.begin(); x_iter != xceptions.end(); ++x_iter) { 
+      f_service_ << indent() << "catch (" << type_name((*x_iter)->get_type(), false, false) << " " 
+        << (*x_iter)->get_name() << ")" << endl 
+        << indent() << "{" << endl; 
+      if (!tfunction->is_oneway()) { 
+        indent_up(); 
+        f_service_ << indent() << "result." << prop_name(*x_iter) << " = " << (*x_iter)->get_name() 
+          << ";" << endl; 
+        indent_down(); 
+      } 
+      f_service_ << indent() << "}" << endl; 
+    } 
+  } 
+  if (!tfunction->is_oneway()) { 
+    f_service_ << indent() << "oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name() 
+      << "\", TMessageType.Reply, seqid)); " << endl; 
+    f_service_ << indent() << "result.Write(oprot);" << endl; 
+  } 
+  indent_down(); 
+ 
+  cleanup_member_name_mapping(xs); 
+ 
+  f_service_ << indent() << "}" << endl 
+    << indent() << "catch (TTransportException)" << endl 
+    << indent() << "{" << endl 
+    << indent() << "  throw;" << endl 
+    << indent() << "}" << endl 
+    << indent() << "catch (Exception ex)" << endl 
+    << indent() << "{" << endl 
+    << indent() << "  Console.Error.WriteLine(\"Error occurred in processor:\");" << endl 
+    << indent() << "  Console.Error.WriteLine(ex.ToString());" << endl; 
+ 
+  if (tfunction->is_oneway()) { 
+    f_service_ << indent() << "}" << endl; 
+  } 
+  else { 
+    f_service_ << indent() << "  TApplicationException x = new TApplicationException" << indent() 
+      << "(TApplicationException.ExceptionType.InternalError,\" Internal error.\");" 
+      << endl 
+      << indent() << "  oprot.WriteMessageBegin(new TMessage(\"" << tfunction->get_name() 
+      << "\", TMessageType.Exception, seqid));" << endl 
+      << indent() << "  x.Write(oprot);" << endl 
+      << indent() << "}" << endl; 
+    f_service_ << indent() << "oprot.WriteMessageEnd();" << endl 
+      << indent() << "oprot.Transport.Flush();" << endl; 
+  } 
+ 
+  scope_down(f_service_); 
+ 
+  f_service_ << endl; 
+} 
+ 
+void t_csharp_generator::generate_csharp_union_reader(std::ostream& out, t_struct* tunion) { 
+  // Thanks to THRIFT-1768, we don't need to check for required fields in the union 
+  const vector<t_field*>& fields = tunion->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+ 
+  indent(out) << "public static " << tunion->get_name() << " Read(TProtocol iprot)" << endl; 
+  scope_up(out); 
+ 
+  out << indent() << "iprot.IncrementRecursionDepth();" << endl; 
+  out << indent() << "try" << endl; 
+  scope_up(out); 
+ 
+  indent(out) << tunion->get_name() << " retval;" << endl; 
+  indent(out) << "iprot.ReadStructBegin();" << endl; 
+  indent(out) << "TField field = iprot.ReadFieldBegin();" << endl; 
+  // we cannot have the first field be a stop -- we must have a single field defined 
+  indent(out) << "if (field.Type == TType.Stop)" << endl; 
+  scope_up(out); 
+  indent(out) << "iprot.ReadFieldEnd();" << endl; 
+  indent(out) << "retval = new ___undefined();" << endl; 
+  scope_down(out); 
+  indent(out) << "else" << endl; 
+  scope_up(out); 
+  indent(out) << "switch (field.ID)" << endl; 
+  scope_up(out); 
+ 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    indent(out) << "case " << (*f_iter)->get_key() << ":" << endl; 
+    indent_up(); 
+    indent(out) << "if (field.Type == " << type_to_enum((*f_iter)->get_type()) << ") {" << endl; 
+    indent_up(); 
+ 
+    indent(out) << type_name((*f_iter)->get_type()) << " temp;" << endl; 
+    generate_deserialize_field(out, (*f_iter), "temp", true); 
+    indent(out) << "retval = new " << (*f_iter)->get_name() << "(temp);" << endl; 
+ 
+    indent_down(); 
+    out << indent() << "} else { " << endl << indent() << "  TProtocolUtil.Skip(iprot, field.Type);" 
+        << endl << indent() << "  retval = new ___undefined();" << endl << indent() << "}" << endl 
+        << indent() << "break;" << endl; 
+    indent_down(); 
+  } 
+ 
+  indent(out) << "default: " << endl; 
+  indent_up(); 
+  indent(out) << "TProtocolUtil.Skip(iprot, field.Type);" << endl << indent() 
+              << "retval = new ___undefined();" << endl; 
+  indent(out) << "break;" << endl; 
+  indent_down(); 
+ 
+  scope_down(out); 
+ 
+  indent(out) << "iprot.ReadFieldEnd();" << endl; 
+ 
+  indent(out) << "if (iprot.ReadFieldBegin().Type != TType.Stop)" << endl; 
+  scope_up(out); 
+  indent(out) << "throw new TProtocolException(TProtocolException.INVALID_DATA);" << endl; 
+  scope_down(out); 
+ 
+  // end of else for TStop 
+  scope_down(out); 
+  indent(out) << "iprot.ReadStructEnd();" << endl; 
+  indent(out) << "return retval;" << endl; 
+  indent_down(); 
+ 
+  scope_down(out); 
+  out << indent() << "finally" << endl; 
+  scope_up(out); 
+  out << indent() << "iprot.DecrementRecursionDepth();" << endl; 
+  scope_down(out); 
+ 
+  indent(out) << "}" << endl << endl; 
+} 
+ 
+void t_csharp_generator::generate_deserialize_field(ostream& out, 
+                                                    t_field* tfield, 
+                                                    string prefix, 
+                                                    bool is_propertyless) { 
+  t_type* type = tfield->get_type(); 
+  while (type->is_typedef()) { 
+    type = ((t_typedef*)type)->get_type(); 
+  } 
+ 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE DESERIALIZE CODE FOR void TYPE: " + prefix + tfield->get_name(); 
+  } 
+ 
+  string name = prefix + (is_propertyless ? "" : prop_name(tfield)); 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_deserialize_struct(out, (t_struct*)type, name); 
+  } else if (type->is_container()) { 
+    generate_deserialize_container(out, type, name); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+    indent(out) << name << " = "; 
+ 
+    if (type->is_enum()) { 
+      out << "(" << type_name(type, false, true) << ")"; 
+    } 
+ 
+    out << "iprot."; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + name; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "ReadBinary();"; 
+        } else { 
+          out << "ReadString();"; 
+        } 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "ReadBool();"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "ReadByte();"; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "ReadI16();"; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "ReadI32();"; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "ReadI64();"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "ReadDouble();"; 
+        break; 
+      default: 
+        throw "compiler error: no C# name for base type " + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      out << "ReadI32();"; 
+    } 
+    out << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO DESERIALIZE FIELD '%s' TYPE '%s'\n", 
+           tfield->get_name().c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_deserialize_struct(ostream& out, 
+                                                     t_struct* tstruct, 
+                                                     string prefix) { 
+  if (union_ && tstruct->is_union()) { 
+    out << indent() << prefix << " = " << type_name(tstruct) << ".Read(iprot);" << endl; 
+  } else { 
+    out << indent() << prefix << " = new " << type_name(tstruct) << "();" << endl << indent() 
+        << prefix << ".Read(iprot);" << endl; 
+  } 
+} 
+ 
+void t_csharp_generator::generate_deserialize_container(ostream& out, 
+                                                        t_type* ttype, 
+                                                        string prefix) { 
+  scope_up(out); 
+ 
+  string obj; 
+ 
+  if (ttype->is_map()) { 
+    obj = tmp("_map"); 
+  } else if (ttype->is_set()) { 
+    obj = tmp("_set"); 
+  } else if (ttype->is_list()) { 
+    obj = tmp("_list"); 
+  } 
+ 
+  indent(out) << prefix << " = new " << type_name(ttype, false, true) << "();" << endl; 
+  if (ttype->is_map()) { 
+    out << indent() << "TMap " << obj << " = iprot.ReadMapBegin();" << endl; 
+  } else if (ttype->is_set()) { 
+    out << indent() << "TSet " << obj << " = iprot.ReadSetBegin();" << endl; 
+  } else if (ttype->is_list()) { 
+    out << indent() << "TList " << obj << " = iprot.ReadListBegin();" << endl; 
+  } 
+ 
+  string i = tmp("_i"); 
+  indent(out) << "for( int " << i << " = 0; " << i << " < " << obj << ".Count" 
+              << "; " 
+              << "++" << i << ")" << endl; 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    generate_deserialize_map_element(out, (t_map*)ttype, prefix); 
+  } else if (ttype->is_set()) { 
+    generate_deserialize_set_element(out, (t_set*)ttype, prefix); 
+  } else if (ttype->is_list()) { 
+    generate_deserialize_list_element(out, (t_list*)ttype, prefix); 
+  } 
+ 
+  scope_down(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "iprot.ReadMapEnd();" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "iprot.ReadSetEnd();" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "iprot.ReadListEnd();" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+void t_csharp_generator::generate_deserialize_map_element(ostream& out, 
+                                                          t_map* tmap, 
+                                                          string prefix) { 
+  string key = tmp("_key"); 
+  string val = tmp("_val"); 
+ 
+  t_field fkey(tmap->get_key_type(), key); 
+  t_field fval(tmap->get_val_type(), val); 
+ 
+  indent(out) << declare_field(&fkey) << endl; 
+  indent(out) << declare_field(&fval) << endl; 
+ 
+  generate_deserialize_field(out, &fkey); 
+  generate_deserialize_field(out, &fval); 
+ 
+  indent(out) << prefix << "[" << key << "] = " << val << ";" << endl; 
+} 
+ 
+void t_csharp_generator::generate_deserialize_set_element(ostream& out, 
+                                                          t_set* tset, 
+                                                          string prefix) { 
+  string elem = tmp("_elem"); 
+  t_field felem(tset->get_elem_type(), elem); 
+ 
+  indent(out) << declare_field(&felem) << endl; 
+ 
+  generate_deserialize_field(out, &felem); 
+ 
+  indent(out) << prefix << ".Add(" << elem << ");" << endl; 
+} 
+ 
+void t_csharp_generator::generate_deserialize_list_element(ostream& out, 
+                                                           t_list* tlist, 
+                                                           string prefix) { 
+  string elem = tmp("_elem"); 
+  t_field felem(tlist->get_elem_type(), elem); 
+ 
+  indent(out) << declare_field(&felem) << endl; 
+ 
+  generate_deserialize_field(out, &felem); 
+ 
+  indent(out) << prefix << ".Add(" << elem << ");" << endl; 
+} 
+ 
+void t_csharp_generator::generate_serialize_field(ostream& out, 
+                                                  t_field* tfield, 
+                                                  string prefix, 
+                                                  bool is_element, 
+                                                  bool is_propertyless) { 
+  t_type* type = tfield->get_type(); 
+  while (type->is_typedef()) { 
+    type = ((t_typedef*)type)->get_type(); 
+  } 
+ 
+  string name = prefix + (is_propertyless ? "" : prop_name(tfield)); 
+ 
+  if (type->is_void()) { 
+    throw "CANNOT GENERATE SERIALIZE CODE FOR void TYPE: " + name; 
+  } 
+ 
+  if (type->is_struct() || type->is_xception()) { 
+    generate_serialize_struct(out, (t_struct*)type, name); 
+  } else if (type->is_container()) { 
+    generate_serialize_container(out, type, name); 
+  } else if (type->is_base_type() || type->is_enum()) { 
+    indent(out) << "oprot."; 
+ 
+    string nullable_name = nullable_ && !is_element && !field_is_required(tfield) ? name + ".Value" 
+                                                                                  : name; 
+ 
+    if (type->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "compiler error: cannot serialize void field in a struct: " + name; 
+        break; 
+      case t_base_type::TYPE_STRING: 
+        if (type->is_binary()) { 
+          out << "WriteBinary("; 
+        } else { 
+          out << "WriteString("; 
+        } 
+        out << name << ");"; 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        out << "WriteBool(" << nullable_name << ");"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+        out << "WriteByte(" << nullable_name << ");"; 
+        break; 
+      case t_base_type::TYPE_I16: 
+        out << "WriteI16(" << nullable_name << ");"; 
+        break; 
+      case t_base_type::TYPE_I32: 
+        out << "WriteI32(" << nullable_name << ");"; 
+        break; 
+      case t_base_type::TYPE_I64: 
+        out << "WriteI64(" << nullable_name << ");"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        out << "WriteDouble(" << nullable_name << ");"; 
+        break; 
+      default: 
+        throw "compiler error: no C# name for base type " + t_base_type::t_base_name(tbase); 
+      } 
+    } else if (type->is_enum()) { 
+      out << "WriteI32((int)" << nullable_name << ");"; 
+    } 
+    out << endl; 
+  } else { 
+    printf("DO NOT KNOW HOW TO SERIALIZE '%s%s' TYPE '%s'\n", 
+           prefix.c_str(), 
+           tfield->get_name().c_str(), 
+           type_name(type).c_str()); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_serialize_struct(ostream& out, 
+                                                   t_struct* tstruct, 
+                                                   string prefix) { 
+  (void)tstruct; 
+  out << indent() << prefix << ".Write(oprot);" << endl; 
+} 
+ 
+void t_csharp_generator::generate_serialize_container(ostream& out, t_type* ttype, string prefix) { 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "oprot.WriteMapBegin(new TMap(" << type_to_enum(((t_map*)ttype)->get_key_type()) 
+                << ", " << type_to_enum(((t_map*)ttype)->get_val_type()) << ", " << prefix 
+                << ".Count));" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "oprot.WriteSetBegin(new TSet(" << type_to_enum(((t_set*)ttype)->get_elem_type()) 
+                << ", " << prefix << ".Count));" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "oprot.WriteListBegin(new TList(" 
+                << type_to_enum(((t_list*)ttype)->get_elem_type()) << ", " << prefix << ".Count));" 
+                << endl; 
+  } 
+ 
+  string iter = tmp("_iter"); 
+  if (ttype->is_map()) { 
+    indent(out) << "foreach (" << type_name(((t_map*)ttype)->get_key_type()) << " " << iter 
+                << " in " << prefix << ".Keys)"; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "foreach (" << type_name(((t_set*)ttype)->get_elem_type()) << " " << iter 
+                << " in " << prefix << ")"; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "foreach (" << type_name(((t_list*)ttype)->get_elem_type()) << " " << iter 
+                << " in " << prefix << ")"; 
+  } 
+ 
+  out << endl; 
+  scope_up(out); 
+ 
+  if (ttype->is_map()) { 
+    generate_serialize_map_element(out, (t_map*)ttype, iter, prefix); 
+  } else if (ttype->is_set()) { 
+    generate_serialize_set_element(out, (t_set*)ttype, iter); 
+  } else if (ttype->is_list()) { 
+    generate_serialize_list_element(out, (t_list*)ttype, iter); 
+  } 
+ 
+  scope_down(out); 
+ 
+  if (ttype->is_map()) { 
+    indent(out) << "oprot.WriteMapEnd();" << endl; 
+  } else if (ttype->is_set()) { 
+    indent(out) << "oprot.WriteSetEnd();" << endl; 
+  } else if (ttype->is_list()) { 
+    indent(out) << "oprot.WriteListEnd();" << endl; 
+  } 
+ 
+  scope_down(out); 
+} 
+ 
+void t_csharp_generator::generate_serialize_map_element(ostream& out, 
+                                                        t_map* tmap, 
+                                                        string iter, 
+                                                        string map) { 
+  t_field kfield(tmap->get_key_type(), iter); 
+  generate_serialize_field(out, &kfield, "", true); 
+  t_field vfield(tmap->get_val_type(), map + "[" + iter + "]"); 
+  generate_serialize_field(out, &vfield, "", true); 
+} 
+ 
+void t_csharp_generator::generate_serialize_set_element(ostream& out, t_set* tset, string iter) { 
+  t_field efield(tset->get_elem_type(), iter); 
+  generate_serialize_field(out, &efield, "", true); 
+} 
+ 
+void t_csharp_generator::generate_serialize_list_element(ostream& out, 
+                                                         t_list* tlist, 
+                                                         string iter) { 
+  t_field efield(tlist->get_elem_type(), iter); 
+  generate_serialize_field(out, &efield, "", true); 
+} 
+ 
+void t_csharp_generator::generate_property(ostream& out, 
+                                           t_field* tfield, 
+                                           bool isPublic, 
+                                           bool generateIsset) { 
+  generate_csharp_property(out, tfield, isPublic, generateIsset, "_"); 
+} 
+void t_csharp_generator::generate_csharp_property(ostream& out, 
+                                                  t_field* tfield, 
+                                                  bool isPublic, 
+                                                  bool generateIsset, 
+                                                  std::string fieldPrefix) { 
+  if ((serialize_ || wcf_) && isPublic) { 
+    indent(out) << "[DataMember(Order = 0)]" << endl; 
+  } 
+  bool has_default = field_has_default(tfield); 
+  bool is_required = field_is_required(tfield); 
+  if ((nullable_ && !has_default) || (is_required)) { 
+    indent(out) << (isPublic ? "public " : "private ") 
+                << type_name(tfield->get_type(), false, false, true, is_required) << " " 
+                << prop_name(tfield) << " { get; set; }" << endl; 
+  } else { 
+    indent(out) << (isPublic ? "public " : "private ") 
+                << type_name(tfield->get_type(), false, false, true) << " " << prop_name(tfield) 
+                << endl; 
+    scope_up(out); 
+    indent(out) << "get" << endl; 
+    scope_up(out); 
+    bool use_nullable = false; 
+    if (nullable_) { 
+      t_type* ttype = tfield->get_type(); 
+      while (ttype->is_typedef()) { 
+        ttype = ((t_typedef*)ttype)->get_type(); 
+      } 
+      if (ttype->is_base_type()) { 
+        use_nullable = ((t_base_type*)ttype)->get_base() != t_base_type::TYPE_STRING; 
+      } else if (ttype->is_enum()) { 
+        use_nullable = true; 
+      } 
+    } 
+    indent(out) << "return " << fieldPrefix + tfield->get_name() << ";" << endl; 
+    scope_down(out); 
+    indent(out) << "set" << endl; 
+    scope_up(out); 
+    if (use_nullable) { 
+      if (generateIsset) { 
+        indent(out) << "__isset." << normalize_name(tfield->get_name()) << " = value.HasValue;" 
+                    << endl; 
+      } 
+      indent(out) << "if (value.HasValue) this." << fieldPrefix + tfield->get_name() 
+                  << " = value.Value;" << endl; 
+    } else { 
+      if (generateIsset) { 
+        indent(out) << "__isset." << normalize_name(tfield->get_name()) << " = true;" << endl; 
+      } 
+      indent(out) << "this." << fieldPrefix + tfield->get_name() << " = value;" << endl; 
+    } 
+    scope_down(out); 
+    scope_down(out); 
+  } 
+  out << endl; 
+} 
+ 
+std::string t_csharp_generator::make_valid_csharp_identifier(std::string const& fromName) { 
+  std::string str = fromName; 
+  if (str.empty()) { 
+    return str; 
+  } 
+ 
+  // tests rely on this 
+  assert(('A' < 'Z') && ('a' < 'z') && ('0' < '9')); 
+ 
+  // if the first letter is a number, we add an additional underscore in front of it 
+  char c = str.at(0); 
+  if (('0' <= c) && (c <= '9')) { 
+    str = "_" + str; 
+  } 
+ 
+  // following chars: letter, number or underscore 
+  for (size_t i = 0; i < str.size(); ++i) { 
+    c = str.at(i); 
+    if ((('A' > c) || (c > 'Z')) && (('a' > c) || (c > 'z')) && (('0' > c) || (c > '9')) 
+        && ('_' != c)) { 
+      str.replace(i, 1, "_"); 
+    } 
+  } 
+ 
+  return str; 
+} 
+ 
+void t_csharp_generator::cleanup_member_name_mapping(void* scope) { 
+  if( member_mapping_scopes.empty()) { 
+    throw "internal error: cleanup_member_name_mapping() no scope active"; 
+  } 
+ 
+  member_mapping_scope& active = member_mapping_scopes.back(); 
+  if (active.scope_member != scope) { 
+    throw "internal error: cleanup_member_name_mapping() called for wrong struct"; 
+  } 
+ 
+  member_mapping_scopes.pop_back(); 
+} 
+ 
+string t_csharp_generator::get_mapped_member_name(string name) { 
+  if( ! member_mapping_scopes.empty()) { 
+    member_mapping_scope& active = member_mapping_scopes.back(); 
+    map<string, string>::iterator iter = active.mapping_table.find(name); 
+    if (active.mapping_table.end() != iter) { 
+      return iter->second; 
+    } 
+  } 
+ 
+  pverbose("no mapping for member %s\n", name.c_str()); 
+  return name; 
+} 
+ 
+void t_csharp_generator::prepare_member_name_mapping(t_struct* tstruct) { 
+  prepare_member_name_mapping(tstruct, tstruct->get_members(), tstruct->get_name()); 
+} 
+ 
+void t_csharp_generator::prepare_member_name_mapping(void* scope, 
+                                                     const vector<t_field*>& members, 
+                                                     const string& structname) { 
+  // begin new scope 
+  member_mapping_scope dummy; 
+  dummy.scope_member = 0; 
+  member_mapping_scopes.push_back(dummy); 
+  member_mapping_scope& active = member_mapping_scopes.back(); 
+  active.scope_member = scope; 
+ 
+  // current C# generator policy: 
+  // - prop names are always rendered with an Uppercase first letter 
+  // - struct names are used as given 
+  std::set<std::string> used_member_names; 
+  vector<t_field*>::const_iterator iter; 
+ 
+  // prevent name conflicts with struct (CS0542 error) 
+  used_member_names.insert(structname); 
+ 
+  // prevent name conflicts with known methods (THRIFT-2942) 
+  used_member_names.insert("Read"); 
+  used_member_names.insert("Write"); 
+ 
+  for (iter = members.begin(); iter != members.end(); ++iter) { 
+    string oldname = (*iter)->get_name(); 
+    string newname = prop_name(*iter, true); 
+    while (true) { 
+ 
+      // new name conflicts with another member 
+      if (used_member_names.find(newname) != used_member_names.end()) { 
+        pverbose("struct %s: member %s conflicts with another member\n", 
+                 structname.c_str(), 
+                 newname.c_str()); 
+        newname += '_'; 
+        continue; 
+      } 
+ 
+      // add always, this helps us to detect edge cases like 
+      // different spellings ("foo" and "Foo") within the same struct 
+      pverbose("struct %s: member mapping %s => %s\n", 
+               structname.c_str(), 
+               oldname.c_str(), 
+               newname.c_str()); 
+      active.mapping_table[oldname] = newname; 
+      used_member_names.insert(newname); 
+      break; 
+    } 
+  } 
+} 
+ 
+std::string t_csharp_generator::prop_name(t_field* tfield, bool suppress_mapping) { 
+  string name(tfield->get_name()); 
+  if (suppress_mapping) { 
+    name[0] = toupper(name[0]); 
+  } else { 
+    name = get_mapped_member_name(name); 
+  } 
+  return name; 
+} 
+ 
+string t_csharp_generator::type_name(t_type* ttype, 
+                                     bool in_container, 
+                                     bool in_init, 
+                                     bool in_param, 
+                                     bool is_required) { 
+  (void)in_init; 
+  while (ttype->is_typedef()) { 
+    ttype = ((t_typedef*)ttype)->get_type(); 
+  } 
+ 
+  if (ttype->is_base_type()) { 
+    return base_type_name((t_base_type*)ttype, in_container, in_param, is_required); 
+  } else if (ttype->is_map()) { 
+    t_map* tmap = (t_map*)ttype; 
+    return "Dictionary<" + type_name(tmap->get_key_type(), true) + ", " 
+           + type_name(tmap->get_val_type(), true) + ">"; 
+  } else if (ttype->is_set()) { 
+    t_set* tset = (t_set*)ttype; 
+    return "THashSet<" + type_name(tset->get_elem_type(), true) + ">"; 
+  } else if (ttype->is_list()) { 
+    t_list* tlist = (t_list*)ttype; 
+    return "List<" + type_name(tlist->get_elem_type(), true) + ">"; 
+  } 
+ 
+  t_program* program = ttype->get_program(); 
+  string postfix = (!is_required && nullable_ && in_param && ttype->is_enum()) ? "?" : ""; 
+  if (program != NULL && program != program_) { 
+    string ns = program->get_namespace("csharp"); 
+    if (!ns.empty()) { 
+      return ns + "." + normalize_name(ttype->get_name()) + postfix; 
+    } 
+  } 
+ 
+  return normalize_name(ttype->get_name()) + postfix; 
+} 
+ 
+string t_csharp_generator::base_type_name(t_base_type* tbase, 
+                                          bool in_container, 
+                                          bool in_param, 
+                                          bool is_required) { 
+  (void)in_container; 
+  string postfix = (!is_required && nullable_ && in_param) ? "?" : ""; 
+  switch (tbase->get_base()) { 
+  case t_base_type::TYPE_VOID: 
+    return "void"; 
+  case t_base_type::TYPE_STRING: 
+    if (tbase->is_binary()) { 
+      return "byte[]"; 
+    } else { 
+      return "string"; 
+    } 
+  case t_base_type::TYPE_BOOL: 
+    return "bool" + postfix; 
+  case t_base_type::TYPE_I8: 
+    return "sbyte" + postfix; 
+  case t_base_type::TYPE_I16: 
+    return "short" + postfix; 
+  case t_base_type::TYPE_I32: 
+    return "int" + postfix; 
+  case t_base_type::TYPE_I64: 
+    return "long" + postfix; 
+  case t_base_type::TYPE_DOUBLE: 
+    return "double" + postfix; 
+  default: 
+    throw "compiler error: no C# name for base type " + t_base_type::t_base_name(tbase->get_base()); 
+  } 
+} 
+ 
+string t_csharp_generator::declare_field(t_field* tfield, bool init, std::string prefix) { 
+  string result = type_name(tfield->get_type()) + " " + prefix + tfield->get_name(); 
+  if (init) { 
+    t_type* ttype = tfield->get_type(); 
+    while (ttype->is_typedef()) { 
+      ttype = ((t_typedef*)ttype)->get_type(); 
+    } 
+    if (ttype->is_base_type() && field_has_default(tfield)) { 
+      std::ofstream dummy; 
+      result += " = " + render_const_value(dummy, tfield->get_name(), ttype, tfield->get_value()); 
+    } else if (ttype->is_base_type()) { 
+      t_base_type::t_base tbase = ((t_base_type*)ttype)->get_base(); 
+      switch (tbase) { 
+      case t_base_type::TYPE_VOID: 
+        throw "NO T_VOID CONSTRUCT"; 
+      case t_base_type::TYPE_STRING: 
+        result += " = null"; 
+        break; 
+      case t_base_type::TYPE_BOOL: 
+        result += " = false"; 
+        break; 
+      case t_base_type::TYPE_I8: 
+      case t_base_type::TYPE_I16: 
+      case t_base_type::TYPE_I32: 
+      case t_base_type::TYPE_I64: 
+        result += " = 0"; 
+        break; 
+      case t_base_type::TYPE_DOUBLE: 
+        result += " = (double)0"; 
+        break; 
+      } 
+    } else if (ttype->is_enum()) { 
+      result += " = (" + type_name(ttype, false, true) + ")0"; 
+    } else if (ttype->is_container()) { 
+      result += " = new " + type_name(ttype, false, true) + "()"; 
+    } else { 
+      result += " = new " + type_name(ttype, false, true) + "()"; 
+    } 
+  } 
+  return result + ";"; 
+} 
+ 
+string t_csharp_generator::function_signature(t_function* tfunction, string prefix) { 
+  t_type* ttype = tfunction->get_returntype(); 
+  return type_name(ttype) + " " + normalize_name(prefix + tfunction->get_name()) + "(" 
+         + argument_list(tfunction->get_arglist()) + ")"; 
+} 
+ 
+string t_csharp_generator::function_signature_async_begin(t_function* tfunction, string prefix) { 
+  string comma = (tfunction->get_arglist()->get_members().size() > 0 ? ", " : ""); 
+  return "IAsyncResult " + normalize_name(prefix + tfunction->get_name()) 
+         + "(AsyncCallback callback, object state" + comma + argument_list(tfunction->get_arglist()) 
+         + ")"; 
+} 
+ 
+string t_csharp_generator::function_signature_async_end(t_function* tfunction, string prefix) { 
+  t_type* ttype = tfunction->get_returntype(); 
+  return type_name(ttype) + " " + normalize_name(prefix + tfunction->get_name()) 
+         + "(IAsyncResult asyncResult)"; 
+} 
+ 
+string t_csharp_generator::function_signature_async(t_function* tfunction, string prefix) { 
+  t_type* ttype = tfunction->get_returntype(); 
+  string task = "Task"; 
+  if (!ttype->is_void()) 
+    task += "<" + type_name(ttype) + ">"; 
+  return task + " " + normalize_name(prefix + tfunction->get_name()) + "Async(" 
+         + argument_list(tfunction->get_arglist()) + ")"; 
+} 
+ 
+string t_csharp_generator::argument_list(t_struct* tstruct) { 
+  string result = ""; 
+  const vector<t_field*>& fields = tstruct->get_members(); 
+  vector<t_field*>::const_iterator f_iter; 
+  bool first = true; 
+  for (f_iter = fields.begin(); f_iter != fields.end(); ++f_iter) { 
+    if (first) { 
+      first = false; 
+    } else { 
+      result += ", "; 
+    } 
+    result += type_name((*f_iter)->get_type()) + " " + normalize_name((*f_iter)->get_name()); 
+  } 
+  return result; 
+} 
+ 
+string t_csharp_generator::type_to_enum(t_type* type) { 
+  while (type->is_typedef()) { 
+    type = ((t_typedef*)type)->get_type(); 
+  } 
+ 
+  if (type->is_base_type()) { 
+    t_base_type::t_base tbase = ((t_base_type*)type)->get_base(); 
+    switch (tbase) { 
+    case t_base_type::TYPE_VOID: 
+      throw "NO T_VOID CONSTRUCT"; 
+    case t_base_type::TYPE_STRING: 
+      return "TType.String"; 
+    case t_base_type::TYPE_BOOL: 
+      return "TType.Bool"; 
+    case t_base_type::TYPE_I8: 
+      return "TType.Byte"; 
+    case t_base_type::TYPE_I16: 
+      return "TType.I16"; 
+    case t_base_type::TYPE_I32: 
+      return "TType.I32"; 
+    case t_base_type::TYPE_I64: 
+      return "TType.I64"; 
+    case t_base_type::TYPE_DOUBLE: 
+      return "TType.Double"; 
+    } 
+  } else if (type->is_enum()) { 
+    return "TType.I32"; 
+  } else if (type->is_struct() || type->is_xception()) { 
+    return "TType.Struct"; 
+  } else if (type->is_map()) { 
+    return "TType.Map"; 
+  } else if (type->is_set()) { 
+    return "TType.Set"; 
+  } else if (type->is_list()) { 
+    return "TType.List"; 
+  } 
+ 
+  throw "INVALID TYPE IN type_to_enum: " + type->get_name(); 
+} 
+ 
+void t_csharp_generator::generate_csharp_docstring_comment(ostream& out, string contents) { 
+  generate_docstring_comment(out, "/// <summary>\n", "/// ", contents, "/// </summary>\n"); 
+} 
+ 
+void t_csharp_generator::generate_csharp_doc(ostream& out, t_field* field) { 
+  if (field->get_type()->is_enum()) { 
+    string combined_message = field->get_doc() + "\n<seealso cref=\"" 
+                              + get_enum_class_name(field->get_type()) + "\"/>"; 
+    generate_csharp_docstring_comment(out, combined_message); 
+  } else { 
+    generate_csharp_doc(out, (t_doc*)field); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_csharp_doc(ostream& out, t_doc* tdoc) { 
+  if (tdoc->has_doc()) { 
+    generate_csharp_docstring_comment(out, tdoc->get_doc()); 
+  } 
+} 
+ 
+void t_csharp_generator::generate_csharp_doc(ostream& out, t_function* tfunction) { 
+  if (tfunction->has_doc()) { 
+    stringstream ps; 
+    const vector<t_field*>& fields = tfunction->get_arglist()->get_members(); 
+    vector<t_field*>::const_iterator p_iter; 
+    for (p_iter = fields.begin(); p_iter != fields.end(); ++p_iter) { 
+      t_field* p = *p_iter; 
+      ps << "\n<param name=\"" << p->get_name() << "\">"; 
+      if (p->has_doc()) { 
+        std::string str = p->get_doc(); 
+        str.erase(std::remove(str.begin(), str.end(), '\n'), 
+                  str.end()); // remove the newlines that appear from the parser 
+        ps << str; 
+      } 
+      ps << "</param>"; 
+    } 
+    generate_docstring_comment(out, 
+                               "", 
+                               "/// ", 
+                               "<summary>\n" + tfunction->get_doc() + "</summary>" + ps.str(), 
+                               ""); 
+  } 
+} 
+ 
+std::string t_csharp_generator::get_enum_class_name(t_type* type) { 
+  string package = ""; 
+  t_program* program = type->get_program(); 
+  if (program != NULL && program != program_) { 
+    package = program->get_namespace("csharp") + "."; 
+  } 
+  return package + type->get_name(); 
+} 
+ 
+ 
+THRIFT_REGISTER_GENERATOR( 
+    csharp, 
+    "C#", 
+    "    async:           Adds Async support using Task.Run.\n" 
+    "    wcf:             Adds bindings for WCF to generated classes.\n" 
+    "    serial:          Add serialization support to generated classes.\n" 
+    "    nullable:        Use nullable types for properties.\n" 
+    "    hashcode:        Generate a hashcode and equals implementation for classes.\n" 
+    "    union:           Use new union typing, which includes a static read function for union " 
+    "types.\n")