taverna-wsdl-generic/src/main/java/net/sf/taverna/wsdl/soap/AbstractBodyBuilder.java - incubator-taverna-common-activities - Git at Google

 /*******************************************************************************
  * Copyright (C) 2007 The University of Manchester
  *
  *  Modifications to the initial code base are copyright of their
  *  respective authors, or their employers as appropriate.
  *
  *  This program is free software; you can redistribute it and/or
  *  modify it under the terms of the GNU Lesser General Public License
  *  as published by the Free Software Foundation; either version 2.1 of
  *  the License, or (at your option) any later version.
  *
  *  This program is distributed in the hope that it will be useful, but
  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  *  Lesser General Public License for more details.
  *
  *  You should have received a copy of the GNU Lesser General Public
  *  License along with this program; if not, write to the Free Software
  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  ******************************************************************************/
 package net.sf.taverna.wsdl.soap;

 import java.io.ByteArrayInputStream;
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import javax.wsdl.WSDLException;
 import javax.xml.namespace.QName;
 import javax.xml.parsers.DocumentBuilder;
 import javax.xml.parsers.DocumentBuilderFactory;
 import javax.xml.parsers.ParserConfigurationException;
 import javax.xml.soap.SOAPException;

 import net.sf.taverna.wsdl.parser.ArrayTypeDescriptor;
 import net.sf.taverna.wsdl.parser.BaseTypeDescriptor;
 import net.sf.taverna.wsdl.parser.ComplexTypeDescriptor;
 import net.sf.taverna.wsdl.parser.TypeDescriptor;
 import net.sf.taverna.wsdl.parser.UnknownOperationException;
 import net.sf.taverna.wsdl.parser.WSDLParser;

 import org.apache.axis.encoding.Base64;
 import org.apache.axis.message.SOAPBodyElement;
 import org.apache.log4j.Logger;
 import org.w3c.dom.Attr;
 import org.w3c.dom.Document;
 import org.w3c.dom.Element;
 import org.w3c.dom.NamedNodeMap;
 import org.w3c.dom.Node;
 import org.xml.sax.SAXException;

 @SuppressWarnings("unchecked")
 public abstract class AbstractBodyBuilder implements BodyBuilder {

 	private static Logger logger = Logger.getLogger(AbstractBodyBuilder.class);

 	private String style;
 	private WSDLParser parser;
 	private String operationName;

 	protected enum Style {
 		DOCUMENT, RPC
 	};

 	protected enum Use {
 		LITERAL, ENCODED
 	};

 	protected Map<String, String> namespaceMappings;
 	protected List<TypeDescriptor> inputDescriptors;

 	public AbstractBodyBuilder(String style, WSDLParser parser,
 			String operationName, List<TypeDescriptor> inputDescriptors) {
 		this.style = style;
 		this.parser = parser;
 		this.operationName = operationName;
 		this.inputDescriptors = inputDescriptors;
 	}

 	protected Style getStyle() {
 		Style result = Style.DOCUMENT;
 		if (style.equalsIgnoreCase("rpc")) {
 			result = Style.RPC;
 		} else if (style.equalsIgnoreCase("document")) {
 			result = Style.DOCUMENT;
 		}
 		return result;
 	}

 	protected abstract Use getUse();

 	/**
 	 *
 	 * @return the namespace for the operation
 	 */
 	private String getOperationNamespace() throws UnknownOperationException {
 		return parser.getOperationNamespaceURI(operationName);
 	}

 	private QName getOperationQname() throws UnknownOperationException {
 		return parser.getOperationQname(operationName);
 	}

 	public SOAPBodyElement build(Map inputMap) throws WSDLException,
 			ParserConfigurationException, SOAPException, IOException,
 			SAXException, UnknownOperationException {

 		List inputs = parser.getOperationInputParameters(operationName);

 		namespaceMappings = generateNamespaceMappings(inputs);

 		QName operationQname = getOperationQname();

 		SOAPBodyElement body = new SOAPBodyElement(operationQname);

 		// its important to preserve the order of the inputs!
 		for (Iterator iterator = inputs.iterator(); iterator.hasNext();) {
 			TypeDescriptor descriptor = (TypeDescriptor) iterator.next();
 			String inputName = descriptor.getName();
 			Object dataValue = inputMap.get(inputName);

 			body = createBodyElementForData(operationName, namespaceMappings,
 					operationQname.getNamespaceURI(), body, descriptor, inputName, dataValue);
 		}

 		return body;
 	}


 	protected SOAPBodyElement createBodyElementForData(String operationName,
 			Map<String, String> namespaceMappings, String operationNamespace,
 			SOAPBodyElement body, TypeDescriptor descriptor, String inputName,
 			Object dataValue) throws ParserConfigurationException,
 			SAXException, IOException, UnknownOperationException, SOAPException {
 		if (dataValue != null) {
 			String mimeType = getMimeTypeForInputName(inputName);
 			String typeName = descriptor.getType();

 			Element el = null;

 			if (descriptor instanceof ArrayTypeDescriptor) {
 				el = createElementForArrayType(namespaceMappings, inputName,
 						dataValue, descriptor, mimeType, typeName);

 			} else {
 				el = createSkeletonElementForSingleItem(namespaceMappings,
 						descriptor, inputName, typeName);
 				populateElementWithObjectData(mimeType, el, dataValue, descriptor);
 			}

 			body = addElementToBody(operationNamespace, body, el);
 		}
 		return body;
 	}

 	protected abstract SOAPBodyElement addElementToBody(
 			String operationNamespace, SOAPBodyElement body, Element el)
 			throws SOAPException;

 	protected abstract Element createSkeletonElementForSingleItem(
 			Map<String, String> namespaceMappings, TypeDescriptor descriptor,
 			String inputName, String typeName);

 	/**
 	 * generates an XML DOM Element for an array
 	 *
 	 * @param namespaceMappings
 	 * @param inputName
 	 * @param dataValue
 	 * @param descriptor
 	 * @param mimeType
 	 * @param typeName
 	 * @return
 	 * @throws ParserConfigurationException
 	 * @throws SAXException
 	 * @throws IOException
 	 */
 	protected abstract Element createElementForArrayType(
 			Map<String, String> namespaceMappings, String inputName,
 			Object dataValue, TypeDescriptor descriptor, String mimeType,
 			String typeName) throws ParserConfigurationException, SAXException,
 			IOException, UnknownOperationException;

 	/**
 	 * Populates a DOM XML Element with the contents of a List of dataValues
 	 *
 	 * @param mimeType -
 	 *            the mime type of the data
 	 * @param element -
 	 *            the Element to be populated
 	 * @param dataValues -
 	 *            the List of Objects containing the data
 	 * @param elementType -
 	 *            the TypeDescriptor for the element being populated
 	 * @throws ParserConfigurationException
 	 * @throws SAXException
 	 * @throws IOException
 	 */
 	protected void populateElementWithList(String mimeType, Element element,
 			List dataValues, TypeDescriptor elementType)
 			throws ParserConfigurationException, SAXException, IOException {
 		for (Iterator dataIterator = dataValues.iterator(); dataIterator
 				.hasNext();) {
 			Object dataItem = dataIterator.next();
 			String tag;
 			if (elementType instanceof BaseTypeDescriptor) {
 				tag = elementType.getType();
 			} else {
 				tag = elementType.getName();
 			}

 			Element item = element.getOwnerDocument().createElement(tag);
 			populateElementWithObjectData(mimeType, item, dataItem, elementType);
 			element.appendChild(item);
 		}
 	}

 	/**
 	 * Populates a DOM XML Element with dataValue according to its mimetype
 	 *
 	 * @param mimeType
 	 * @param element
 	 * @param dataValue
 	 * @param descriptor
 	 * @throws ParserConfigurationException
 	 * @throws SAXException
 	 * @throws IOException
 	 */
 	protected void populateElementWithObjectData(String mimeType,
 			Element element, Object dataValue, TypeDescriptor descriptor)
 			throws ParserConfigurationException, SAXException, IOException {
 		DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 		factory.setNamespaceAware(true);
 		DocumentBuilder builder = factory.newDocumentBuilder();

 		if (mimeType.equals("'text/xml'")) {
 			Document doc = builder.parse(new ByteArrayInputStream(dataValue
 					.toString().getBytes()));
 			Element documentElement = doc.getDocumentElement();

 			if (descriptor instanceof ComplexTypeDescriptor) {
 				ComplexTypeDescriptor complexType = (ComplexTypeDescriptor) descriptor;
 				NamedNodeMap attributes = documentElement.getAttributes();
 				if (attributes != null) {
 					for (int i = 0; i < attributes.getLength(); i++) {
 						Node attributeNode = attributes.item(i);
 						if (attributeNode instanceof Attr) {
 							Attr attribute = (Attr) attributeNode;
 							TypeDescriptor typeDescriptor = complexType.attributeForName(attribute.getName());
 							if (typeDescriptor != null) {
 								element.setAttributeNS(typeDescriptor.getNamespaceURI(), typeDescriptor.getName(), attribute.getValue());
 							}
 						}
 					}
 				}
 			}

 			Node child = documentElement.getFirstChild();

 			while (child != null) {
 				element.appendChild(element.getOwnerDocument().importNode(
 						child, true));
 				child = child.getNextSibling();
 			}
 		} else if (mimeType.equals("'application/octet-stream'")
 				&& dataValue instanceof byte[]) {
 			String encoded = Base64.encode((byte[]) dataValue);
 			element.appendChild(element.getOwnerDocument().createTextNode(
 					encoded));
 		} else {
 			element.appendChild(element.getOwnerDocument().createTextNode(
 					dataValue.toString()));
 		}
 	}

 	/**
 	 * Provides the mime type for a given input
 	 *
 	 * @param inputName
 	 * @return
 	 */
 	protected String getMimeTypeForInputName(String inputName) {
 		for (TypeDescriptor desc : inputDescriptors) {
 			if (desc.getName().equals(inputName))
 				return desc.getMimeType();
 		}
 		return "";
 	}

 	/**
 	 * Generates a map of all the namespaces for the operation and all of the
 	 * types required to call the operation. Namesspace prefixes (the key) start
 	 * with ns1 representing the operation, and continue incrementally for all
 	 * additional namespaces (ns2, ns3 ... etc).
 	 *
 	 * @return
 	 * @param inputs -
 	 *            List of input TypeDescriptor's
 	 * @throws UnknownOperationException
 	 * @throws IOException
 	 */
 	protected Map<String, String> generateNamespaceMappings(List inputs)
 			throws UnknownOperationException, IOException {
 		Map<String, String> result = new HashMap<String, String>();
 		int nsCount = 2;

 		result.put(getOperationNamespace(), "ns1");
 		result.put("http://www.w3.org/2001/XMLSchema", "xsd");
 		result.put("http://www.w3.org/2001/XMLSchema-instance", "xsi");

 		for (Iterator iterator = inputs.iterator(); iterator.hasNext();) {
 			TypeDescriptor descriptor = (TypeDescriptor) iterator.next();
 			nsCount = mapNamespace(descriptor, new ArrayList<TypeDescriptor>(),result, nsCount);

 		}

 		return result;
 	}

 	/**
 	 * creates a namespace prefix and adds the namespace to the namespaceMap for
 	 * a TypeDescriptor. Further recursive calls are made if this type contains
 	 * addition inner elements that are not already mapped.
 	 *
 	 * @param descriptor
 	 * @param namespaceMap
 	 * @param nsCount
 	 * @return
 	 */
 	protected int mapNamespace(TypeDescriptor descriptor, List<TypeDescriptor> visitedDescriptors,
 			Map<String, String> namespaceMap, int nsCount) {
 		if (!visitedDescriptors.contains(descriptor)) {
 			visitedDescriptors.add(descriptor);
 			String namespace = descriptor.getNamespaceURI();
 			if (namespace != null && namespace.length() > 0
 					&& !namespaceMap.containsKey(namespace)) {
 				namespaceMap.put(namespace, "ns" + nsCount);
 				nsCount++;
 			}

 			if (descriptor instanceof ArrayTypeDescriptor) {
 				nsCount = mapNamespace(((ArrayTypeDescriptor) descriptor)
 						.getElementType(),visitedDescriptors, namespaceMap, nsCount);
 			} else if (descriptor instanceof ComplexTypeDescriptor) {
 				List elements = ((ComplexTypeDescriptor) descriptor).getElements();
 				for (Iterator iterator = elements.iterator(); iterator.hasNext();) {
 					nsCount = mapNamespace((TypeDescriptor) iterator.next(),visitedDescriptors,
 							namespaceMap, nsCount);
 				}
 			}
 		}
 		else {
 			logger.error("The descriptor: "+descriptor+" is appears to be part of a cyclic schema. Bailing out of mapping namespace.");
 		}

 		return nsCount;
 	}
 }
	/*******************************************************************************
	* Copyright (C) 2007 The University of Manchester
	*
	* Modifications to the initial code base are copyright of their
	* respective authors, or their employers as appropriate.
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public License
	* as published by the Free Software Foundation; either version 2.1 of
	* the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful, but
	* WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
	******************************************************************************/
	package net.sf.taverna.wsdl.soap;

	import java.io.ByteArrayInputStream;
	import java.io.IOException;
	import java.util.ArrayList;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import javax.wsdl.WSDLException;
	import javax.xml.namespace.QName;
	import javax.xml.parsers.DocumentBuilder;
	import javax.xml.parsers.DocumentBuilderFactory;
	import javax.xml.parsers.ParserConfigurationException;
	import javax.xml.soap.SOAPException;

	import net.sf.taverna.wsdl.parser.ArrayTypeDescriptor;
	import net.sf.taverna.wsdl.parser.BaseTypeDescriptor;
	import net.sf.taverna.wsdl.parser.ComplexTypeDescriptor;
	import net.sf.taverna.wsdl.parser.TypeDescriptor;
	import net.sf.taverna.wsdl.parser.UnknownOperationException;
	import net.sf.taverna.wsdl.parser.WSDLParser;

	import org.apache.axis.encoding.Base64;
	import org.apache.axis.message.SOAPBodyElement;
	import org.apache.log4j.Logger;
	import org.w3c.dom.Attr;
	import org.w3c.dom.Document;
	import org.w3c.dom.Element;
	import org.w3c.dom.NamedNodeMap;
	import org.w3c.dom.Node;
	import org.xml.sax.SAXException;

	@SuppressWarnings("unchecked")
	public abstract class AbstractBodyBuilder implements BodyBuilder {

	private static Logger logger = Logger.getLogger(AbstractBodyBuilder.class);

	private String style;
	private WSDLParser parser;
	private String operationName;

	protected enum Style {
	DOCUMENT, RPC
	};

	protected enum Use {
	LITERAL, ENCODED
	};

	protected Map<String, String> namespaceMappings;
	protected List<TypeDescriptor> inputDescriptors;

	public AbstractBodyBuilder(String style, WSDLParser parser,
	String operationName, List<TypeDescriptor> inputDescriptors) {
	this.style = style;
	this.parser = parser;
	this.operationName = operationName;
	this.inputDescriptors = inputDescriptors;
	}

	protected Style getStyle() {
	Style result = Style.DOCUMENT;
	if (style.equalsIgnoreCase("rpc")) {
	result = Style.RPC;
	} else if (style.equalsIgnoreCase("document")) {
	result = Style.DOCUMENT;
	}
	return result;
	}

	protected abstract Use getUse();

	/**
	*
	* @return the namespace for the operation
	*/
	private String getOperationNamespace() throws UnknownOperationException {
	return parser.getOperationNamespaceURI(operationName);
	}

	private QName getOperationQname() throws UnknownOperationException {
	return parser.getOperationQname(operationName);
	}

	public SOAPBodyElement build(Map inputMap) throws WSDLException,
	ParserConfigurationException, SOAPException, IOException,
	SAXException, UnknownOperationException {

	List inputs = parser.getOperationInputParameters(operationName);

	namespaceMappings = generateNamespaceMappings(inputs);

	QName operationQname = getOperationQname();

	SOAPBodyElement body = new SOAPBodyElement(operationQname);

	// its important to preserve the order of the inputs!
	for (Iterator iterator = inputs.iterator(); iterator.hasNext();) {
	TypeDescriptor descriptor = (TypeDescriptor) iterator.next();
	String inputName = descriptor.getName();
	Object dataValue = inputMap.get(inputName);

	body = createBodyElementForData(operationName, namespaceMappings,
	operationQname.getNamespaceURI(), body, descriptor, inputName, dataValue);
	}

	return body;
	}



	protected SOAPBodyElement createBodyElementForData(String operationName,
	Map<String, String> namespaceMappings, String operationNamespace,
	SOAPBodyElement body, TypeDescriptor descriptor, String inputName,
	Object dataValue) throws ParserConfigurationException,
	SAXException, IOException, UnknownOperationException, SOAPException {
	if (dataValue != null) {
	String mimeType = getMimeTypeForInputName(inputName);
	String typeName = descriptor.getType();

	Element el = null;

	if (descriptor instanceof ArrayTypeDescriptor) {
	el = createElementForArrayType(namespaceMappings, inputName,
	dataValue, descriptor, mimeType, typeName);

	} else {
	el = createSkeletonElementForSingleItem(namespaceMappings,
	descriptor, inputName, typeName);
	populateElementWithObjectData(mimeType, el, dataValue, descriptor);
	}

	body = addElementToBody(operationNamespace, body, el);
	}
	return body;
	}

	protected abstract SOAPBodyElement addElementToBody(
	String operationNamespace, SOAPBodyElement body, Element el)
	throws SOAPException;

	protected abstract Element createSkeletonElementForSingleItem(
	Map<String, String> namespaceMappings, TypeDescriptor descriptor,
	String inputName, String typeName);

	/**
	* generates an XML DOM Element for an array
	*
	* @param namespaceMappings
	* @param inputName
	* @param dataValue
	* @param descriptor
	* @param mimeType
	* @param typeName
	* @return
	* @throws ParserConfigurationException
	* @throws SAXException
	* @throws IOException
	*/
	protected abstract Element createElementForArrayType(
	Map<String, String> namespaceMappings, String inputName,
	Object dataValue, TypeDescriptor descriptor, String mimeType,
	String typeName) throws ParserConfigurationException, SAXException,
	IOException, UnknownOperationException;

	/**
	* Populates a DOM XML Element with the contents of a List of dataValues
	*
	* @param mimeType -
	* the mime type of the data
	* @param element -
	* the Element to be populated
	* @param dataValues -
	* the List of Objects containing the data
	* @param elementType -
	* the TypeDescriptor for the element being populated
	* @throws ParserConfigurationException
	* @throws SAXException
	* @throws IOException
	*/
	protected void populateElementWithList(String mimeType, Element element,
	List dataValues, TypeDescriptor elementType)
	throws ParserConfigurationException, SAXException, IOException {
	for (Iterator dataIterator = dataValues.iterator(); dataIterator
	.hasNext();) {
	Object dataItem = dataIterator.next();
	String tag;
	if (elementType instanceof BaseTypeDescriptor) {
	tag = elementType.getType();
	} else {
	tag = elementType.getName();
	}

	Element item = element.getOwnerDocument().createElement(tag);
	populateElementWithObjectData(mimeType, item, dataItem, elementType);
	element.appendChild(item);
	}
	}

	/**
	* Populates a DOM XML Element with dataValue according to its mimetype
	*
	* @param mimeType
	* @param element
	* @param dataValue
	* @param descriptor
	* @throws ParserConfigurationException
	* @throws SAXException
	* @throws IOException
	*/
	protected void populateElementWithObjectData(String mimeType,
	Element element, Object dataValue, TypeDescriptor descriptor)
	throws ParserConfigurationException, SAXException, IOException {
	DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
	factory.setNamespaceAware(true);
	DocumentBuilder builder = factory.newDocumentBuilder();

	if (mimeType.equals("'text/xml'")) {
	Document doc = builder.parse(new ByteArrayInputStream(dataValue
	.toString().getBytes()));
	Element documentElement = doc.getDocumentElement();

	if (descriptor instanceof ComplexTypeDescriptor) {
	ComplexTypeDescriptor complexType = (ComplexTypeDescriptor) descriptor;
	NamedNodeMap attributes = documentElement.getAttributes();
	if (attributes != null) {
	for (int i = 0; i < attributes.getLength(); i++) {
	Node attributeNode = attributes.item(i);
	if (attributeNode instanceof Attr) {
	Attr attribute = (Attr) attributeNode;
	TypeDescriptor typeDescriptor = complexType.attributeForName(attribute.getName());
	if (typeDescriptor != null) {
	element.setAttributeNS(typeDescriptor.getNamespaceURI(), typeDescriptor.getName(), attribute.getValue());
	}
	}
	}
	}
	}

	Node child = documentElement.getFirstChild();

	while (child != null) {
	element.appendChild(element.getOwnerDocument().importNode(
	child, true));
	child = child.getNextSibling();
	}
	} else if (mimeType.equals("'application/octet-stream'")
	&& dataValue instanceof byte[]) {
	String encoded = Base64.encode((byte[]) dataValue);
	element.appendChild(element.getOwnerDocument().createTextNode(
	encoded));
	} else {
	element.appendChild(element.getOwnerDocument().createTextNode(
	dataValue.toString()));
	}
	}

	/**
	* Provides the mime type for a given input
	*
	* @param inputName
	* @return
	*/
	protected String getMimeTypeForInputName(String inputName) {
	for (TypeDescriptor desc : inputDescriptors) {
	if (desc.getName().equals(inputName))
	return desc.getMimeType();
	}
	return "";
	}

	/**
	* Generates a map of all the namespaces for the operation and all of the
	* types required to call the operation. Namesspace prefixes (the key) start
	* with ns1 representing the operation, and continue incrementally for all
	* additional namespaces (ns2, ns3 ... etc).
	*
	* @return
	* @param inputs -
	* List of input TypeDescriptor's
	* @throws UnknownOperationException
	* @throws IOException
	*/
	protected Map<String, String> generateNamespaceMappings(List inputs)
	throws UnknownOperationException, IOException {
	Map<String, String> result = new HashMap<String, String>();
	int nsCount = 2;

	result.put(getOperationNamespace(), "ns1");
	result.put("http://www.w3.org/2001/XMLSchema", "xsd");
	result.put("http://www.w3.org/2001/XMLSchema-instance", "xsi");

	for (Iterator iterator = inputs.iterator(); iterator.hasNext();) {
	TypeDescriptor descriptor = (TypeDescriptor) iterator.next();
	nsCount = mapNamespace(descriptor, new ArrayList<TypeDescriptor>(),result, nsCount);

	}

	return result;
	}

	/**
	* creates a namespace prefix and adds the namespace to the namespaceMap for
	* a TypeDescriptor. Further recursive calls are made if this type contains
	* addition inner elements that are not already mapped.
	*
	* @param descriptor
	* @param namespaceMap
	* @param nsCount
	* @return
	*/
	protected int mapNamespace(TypeDescriptor descriptor, List<TypeDescriptor> visitedDescriptors,
	Map<String, String> namespaceMap, int nsCount) {
	if (!visitedDescriptors.contains(descriptor)) {
	visitedDescriptors.add(descriptor);
	String namespace = descriptor.getNamespaceURI();
	if (namespace != null && namespace.length() > 0
	&& !namespaceMap.containsKey(namespace)) {
	namespaceMap.put(namespace, "ns" + nsCount);
	nsCount++;
	}

	if (descriptor instanceof ArrayTypeDescriptor) {
	nsCount = mapNamespace(((ArrayTypeDescriptor) descriptor)
	.getElementType(),visitedDescriptors, namespaceMap, nsCount);
	} else if (descriptor instanceof ComplexTypeDescriptor) {
	List elements = ((ComplexTypeDescriptor) descriptor).getElements();
	for (Iterator iterator = elements.iterator(); iterator.hasNext();) {
	nsCount = mapNamespace((TypeDescriptor) iterator.next(),visitedDescriptors,
	namespaceMap, nsCount);
	}
	}
	}
	else {
	logger.error("The descriptor: "+descriptor+" is appears to be part of a cyclic schema. Bailing out of mapping namespace.");
	}

	return nsCount;
	}
	}