import stringimport inspectimport itertools"""<summary>BiWsdlStubCodeGen implements an abstract class for generating WSDL stubs.</summary>"""class BiWsdlCodeGenEngine(object):   """   <summary>   Construct a BiWsdlStubCodeGen object.      </summary>   """   def __init__(self):      self.__commentMode="default"   """   <summary>   Set stub code generator configuration.   Configuration consists of a dictionary with string keys; for each key, method set<keyname> is called, with the key's corresponding value passed as a parameter.   </summary>   <param name="aConfig">Configuration object for code generator. Contains keyed properties   for configuring the code generator; properties are all strings, usually read dynamically   in configuration </param>   """   def applyConfig(self, aConfig):      # Iterate through config properties,      for lProperty in aConfig.keys():         # Devise config setter method         lMethodName = "set" + string.capitalize(lProperty)         # And attempt to invoke it to set configuration         lMeth = getattr(self, lMethodName)         lMeth(aConfig[lProperty])   """   <summary>   Set comments mode.   Comments mode is a string describing how comments should be emitted.   Empty string means no comments. "default" means a default set of comments (can be empty).   Other values are derivative-specific.   </summary>   <param name="aCommentsMode">New value for comments mode.</param>   """   def setComments(self, aCommentsMode):      self.__commentMode=aCommentsMode   """   <summary>   Retrieve current comments mode.   </summary>   """   def getComments(self):      return self.__commentMode   """   <summary>   startService -- Starts generation of code for service   </summary>   <param name="aServiceName">Name of generated service.</param>   """   def startService(self, aServiceName):      self.__serviceName = aServiceName   """   <summary>   endService -- Ends generation of code for service   </summary>   <param name="aServiceName">Name of generated service.</param>   """   def endService(self, aServiceName):      self.__serviceName = ""   """   <summary>   startPort -- Starts generation of code for port   </summary>   <param name="aPort">Name of generated port type.</param>   """   def startPort(self, aPort):      self.__portName = aPort   """   <summary>   endPort -- Ends generation of code for service   </summary>   <param name="aPort">Name of generated port type.</param>   """   def endPort(self, aPort):      self.__portName = ""   """   <summary>   genOperation -- Generate operation for current port.   </summary>   <param name="aMethodName">Name of generated operation</param>   <param name="aArgs">List of names of arguments to operation</param>   <param name="aArgTypes">List of types of arguments, index-corresponding to aArgs</param>   """   def genMethod(self, aMethodName, aArgs, aArgTypes):      pass   """   <summary>   Return the name of the currenly defined service   </summary>   """   def getCurrentService(self):      return self.__serviceName   """   <summary>   Return the name of the currently defined port   </summary>   """   def getCurrentPort(self):      return self.__portName   """   <summary>   Abstract: startGen -- Starts generation of code.   This must be called before any other generation method.   </summary>   """   def startGen(self):      pass   """   <summary>   Abstract: endGen -- Ends generation of code.   This must be called when no more generation methods are to be called.   </summary>   """   def endGen(self):      pass   """   <summary>   Generate a single service using this code generator. This should only be called   after a call to startGen. This must be followed, eventually (that is not necessarily   immediately) by a call to endGen.   </summary>   <param name="aService">Service to generate.</param>   """   def generateService(self, aService):      # Start geneating required service      self.startService(aService.getName())      # for each port in the service,      for lPortName in aService.getPortNames():         # Start generating the port,         self.startPort(lPortName)         # Get the port operations,         lPortType = aService.getPortBinding(lPortName).getPortType()         lPortOps = lPortType.getOperationNames()         # For each operation,         for lPortOpName in lPortOps:            # Get list of parameters and parameter typs            lPortOp = lPortType.getOperation(lPortOpName)            lParts = lPortOp.getInputMessage().getPartNames()            lPartTypes = list(               itertools.imap(lambda lPartName:                              lPortOp.getInputMessage().getPart(lPartName).getType(), lParts))                        # And generate the method            self.genMethod(lPortOpName, lParts, lPartTypes)         # Finish up with Port         self.endPort(lPortName)      # Finish up with service      self.endService(aService.getName())"""<summary>BiWsdlStubCodeGenEngineAggregator implements an aggregator for code generation engines.</summary>"""class BiWsdlCodeGenEngineAggregator(BiWsdlCodeGenEngine):   """   <summary>   Construct a BiWsdlStubCodeGenEngineAggregator object.      </summary>   """   def __init__(self):      super(BiWsdlCodeGenEngineAggregator, self).__init__()      self.__aggregatedEngines = []   def startService(self, aServiceName):      for lEngine in self.__aggregatedEngines: lEngine.startService(aServiceName)   def endService(self, aServiceName):      for lEngine in self.__aggregatedEngines: lEngine.endService(aServiceName)   def startPort(self, aPort):      for lEngine in self.__aggregatedEngines: lEngine.startPort(aPort)   def endPort(self, aPort):      for lEngine in self.__aggregatedEngines: lEngine.endPort(aPort)   def genMethod(self, aMethodName, aArgs, aArgTypes):      for lEngine in self.__aggregatedEngines: lEngine.genMethod(aMethodName, aArgs, aArgTypes)         def startGen(self):      for lEngine in self.__aggregatedEngines: lEngine.startGen()   def endGen(self):      for lEngine in self.__aggregatedEngines: lEngine.endGen()   def addEngine(self, aEngine):      self.__aggregatedEngines.append(aEngine)