Change log for SSOAP package


  • Added WSSEAuth class and conversion to XML node for header of SOAP request.
  • Additions to merging the .soapHeader argument into the Header, including creating the Header node if the .soapHeader object doesn't contain it, and coercing the object to an XMLInternalNode.
  • 0.8-3

  • Further changes to toSOAP() and adding the content to an XML node. Identified by Jeff Allen.
  • 0.8-2

  • Fix for creating . Identified by Dylan Beaudette.
  • 0.8-0

  • Restored the ability to the generated interface code and classes to a file that can be source()ed into another R session or used as code in a package. See writeInterface().
  • 0.7-0

  • Support for HTTP GET and POST methods for WSDL.
  • New, simpler approach to processing/gathering schema types.
  • Support for many more WSDLs/schema.
  • Significant improvements to XMLSchema and mapping descriptions of data types to and from XML.
  • 0.6-0

  • Added methods to coerce a list to an S4 object so that the caller of a WSDL method expecting an S4 object(s) can provide just a list of the slots.
  • Discard parameters in WSDL methods that call for an empty object/element.
  • Allow the caller to specify which port by name or by number to allow the selection of differnt types of interfaces.
  • Added more support for targetNamespace and elementFormDefault.
  • Many changes (along with those to XMLSchema) to process more data types and WSDLs.
  • Support for processing <wsdl:import:gt; nodes in addition to schema import nodes.
  • 0.5-7

  • Fixes for working with brenda.wsdl.
  • Removed the XMLRPC functions. See the XMLRPC package.
  • 0.5-6


  • Patches from Alexandre Rademaker.
    • processWSDL() when "XMLAbstractDocument" passed.
    • Fix PDF documentation for Users Guide
  • 0.5-5

  • Patches from Seth Falcon to fix methods for $, UTF-8 issues with quotes, etc. (Thanks.)
  • 0.5-4

  • Fixed a bug in creating the XML for the body of the request and converting the arguments to XML in toSOAP().
    The issue was parenting and reparenting the new nodes. These are added to the parent explicitly in writeSOAPBody() rather than implicitly in the toSOAP() methods.
  • 0.5-3

  • Added support for dealing with fancy quotes when processing method definitions and generating R code.
  • 0.5-2

  • Suport for elementFormQualified in .SOAP() and genSOAPClientInterface() from the schema definition.
    This controls whether XML elements representing arguments in SOAP method calls use the target namespace of the method or not.
  • 0.5-1

  • Update toSOAP methods to work with XMLInternalDocument objects rather than connections.
  • 0.5-0

  • Introduced richer support for date, datetime and time types, allowing the user to specify values as POSIXt or character types.
    Classes SOAPDate, SOAPDateTime and SOAPTime used to aid in writing methods for toSOAP() and fromSOAP().
  • [Important] Functions generated from the WSDL use ... as the arguments for the RCurl parameters .opts, i.e. .opts = list(...)
  • Added .soapHeader parameter to .SOAP function to allow a function, XML node, or XML text to be supplied as the content for the header node of the SOAP Envelope.
    This is often used for authentication, etc. in the SOAP request.
  • Added addSoapHeader parameter to genSOAPClientInterface() to control whether .soapHeader is added as a parameter to each generated function.
  • Generating converters from XML nodes to instances of the defined WSDL classes and arrays directly rather than determining the conversion steps run-time.
  • Use the converter function rather than the type in the .convert.
  • .convert argument to .SOAP can be the name of a class and will be used in a call to as(xmlNode, .convert). This allows one to define setAs() methods for converting XMLAbstractNode objects to
  • Using XMLInternalNode objects to create the envelope (header, body) of the SOAP request
  • Additions to handle different aspects of XML schema in WSDL files.
  • 0.4-8

  • Avoid using dQuote() when creating code for function definitions as, within certain locales, this can create code that is not parseable by R.
  • 0.4-7

  • Better handling of anyType.
  • Handle case when there are no types.
  • 0.4-6

  • Some documentation fixes and generally fixing up warnings.
  • 0.4-5

  • resolve() methods handle working with multiple schema and being able to resolve, e.g., fields with types in different schemas.
  • Added support for xsd:anyType.
  • Use a class SOAPResolveError for signalling errors related to resolving types in schema so that we can catch those errors.
  • 0.4-4

    Changes for dealing with WSDL files
  • Added the arguments passed via the ... in generated functions to the actual .SOAP() call, e.g. for nameSpaces
  • Handle description of fields/elements in structures more directly so that the generated code is more complete.
  • Handle more cases during the processing (e.g. element nodes that point to other nodes in the schema).
  • .SOAP accepts nameSpaces argument as the name of an element in the .SOAPDefaultNameSpaces list, e.g. "1.1" or "1.2" as well as a character vector of alias=URI pairs
  • Handle enumeration types.
  • Examples of WSDL code generation in examples/KEGG.S and tests/interop.R work. Can also process eBay developer's WSDL. (More work needed to make the calls with the authentication.)
  • 0.4-3

  • Removed the setGeneric() for "names" that prohibited the package from being installed after changes to the methods package.
  • 0.4-2

  • Fix for the emission of warnings for nodes of the form value when attempting to convert them from SOAP to R.
  • processWSDL() now separates the different schema in the types node into SchemaContainer and creates "SchemaTypes" lists with methods for resolve() to make the lookup of a particular type more structured.
  • 0.4-1

  • Fix for the generation of the URL from a SOAPServer object which incorrectly inserted a port. The parsing of the URI using the XML package returned a value of 0 rather than NA when there is no port. Fixed in XML package and here.
  • 0.4-0

  • Tested using HTTPS (HTTP over SSL).
  • Determine the protocol (http, https, etc.) from the SOAPServer object
    See getProtocol() which is not exported.
  • Support for base64Binary return types types.
    Need RCurl >= 0.8-0
  • Honor the fromConverter in the BasicSOAPType objects when converting a SOAP response to R.
  • SOAPTypes structure has changed so each element is a list and can contain converter functions for convert to SOAP from R (to), and to R from SOAP (from).
  • Issue: Still issues with namespaces and matching prefix to URIs when resolving types.
  • 0.3-0

  • Programmatically generated bindings perform coercion of both arguments to the appropriate type and of the return value class, if the return type is a newly defined class in the WSDL file.
  • parseArrayType() returns a single ArrayType object (not a list of ArrayType objects) with a vector giving the dimensions of the nested arrays.
  • More work to check if this covers the complete set of cases is needed.
  • Fix for processing the updated KEGG WSDL
  • Added some support for using/checking namespaces in the processing of the schema.
  • New interface for calling methods via a server object, i.e. keggServer$list_databases().
    The server is created from a "SOAPClientInterface" instance created from genSOAPClientInterface.
  • Added a server argument to genSOAPClientInterface() which defaults to the server description object read from the WSDL file. This can however be used to create
  • Functions generated via genSOAPClientInterface() (and createOperationDefinition()) now have an explicit environment whose parent is that specified via the env argument (of both functions).
  • Added a curlHandle arguemnt .SOAP so that one can supply previously created handles with options, connections, etc. to the SOAP operation.
  • processWSDL takes a handler argument that is used to perform imports, etc. The default is an internal function in the package named WSDLParseHandlers.
  • 0.2-4

  • fromSOAPArray() calls unlist to create a vector if the element types are primitive (i.e. numbers, strings, logicals).
  • Deals better with element type objects (i.e. SOAPType) when explicitly passed to fromSOAPArray
  • Update KEGG.wsdl to new version. And the KEGG.S examples to use class slots rather than list elements, i.e. iface@functions rather than iface$functions.
  • Handle NULL return values in fromSOAPArray as this function can be called when the type is known from, e.g., processing a WSDL file but the return value is actually NULL.
  • 0.2-3

  • License switched to GPL2 from BSD.
    Previous versions are still available under the BSD license.
  • Empty/zero-length arrays are returned as character(0), integer(0), numeric(0), logical(0), etc. as appropriate to the element type or list(0). This is a change from returning NULL.
  • Fix in fromSOAPArray when computing the name of the type from the arrayType attribute.
    The array declaration is now parsed more thoroughly and an ArrayType object with the dimensions is created.
  • Global option SSOAP:DefaultNamespace that can be set to "1.1" or "1.2"
    The naming convention (pkg:variable name) is consistent with XML attributes and probably a reasonable one to adopt for R's namespace mechanism and options for particular packages.
  • Patch from Nigel Sim to handle soapenc: namespace entries.
  • dims field added to ArrayType class.
  • 0.2-2


  • isHTTPError() recognizes status codes 100, 200, 201, ..., 206 as being error-free responses.
    The 100 error message is for CONTINUE, but hopefully can be ignored since the entire request was sent by the client.
  • Documentation updates and fixed trivial documentation links.
  • Support for WSDL still needs some work in the case of arrays of complex types. More to come on reading Schema generally.
  • 0.2-0

  • Support for reading WSDL files (either locally or via HTTP) and generating S interface to the server and its methods.
  • UseDashInNames option in R can now be set to control whether the function, field and class names generated during the processing of the WSDL information are converted to myRoutine or left as my_routine.
  • Use RCurl to implement the HTTP request.

  • Duncan Temple Lang <>
    Last modified: Thu Jan 12 14:51:35 PST 2012