biwsdlcodegen.py

ajax 框价．是个好工具．javascript 矿家．可以用在任何平台．

import string
import inspect
import 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)