bundles/org.eclipse.wst.wsdl/src-wsdl/org/eclipse/wst/wsdl/internal/generator/BindingGenerator.java - webservices/webtools.webservices - Git at Google

 package org.eclipse.wst.wsdl.internal.generator;

 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;

 import javax.xml.namespace.QName;

 import org.eclipse.wst.wsdl.Binding;
 import org.eclipse.wst.wsdl.BindingFault;
 import org.eclipse.wst.wsdl.BindingInput;
 import org.eclipse.wst.wsdl.BindingOperation;
 import org.eclipse.wst.wsdl.BindingOutput;
 import org.eclipse.wst.wsdl.Definition;
 import org.eclipse.wst.wsdl.ExtensibilityElement;
 import org.eclipse.wst.wsdl.ExtensibleElement;
 import org.eclipse.wst.wsdl.Fault;
 import org.eclipse.wst.wsdl.Input;
 import org.eclipse.wst.wsdl.Operation;
 import org.eclipse.wst.wsdl.Output;
 import org.eclipse.wst.wsdl.Port;
 import org.eclipse.wst.wsdl.PortType;
 import org.eclipse.wst.wsdl.Service;
 import org.eclipse.wst.wsdl.WSDLFactory;
 import org.eclipse.wst.wsdl.internal.generator.extension.ContentGeneratorExtensionFactoryRegistry;

 /*
  * Class used to generate the Binding and it's content.  We look in the registry for
  * appropriate ContentGenerator classes based on the existing Binding Content's namespace.
  * Alternatively, users can pass in a namespace through the constructor to specify which
  * namespace to use when searching the registry.
  *
  * The ContentGenerator may also be set manually by calling
  * setContentGenerator(ContentGenerator).
  */
 public class BindingGenerator extends BaseGenerator {
 	private WSDLFactory factory = WSDLFactory.eINSTANCE;
 	private Binding binding;

 	/*
 	 * When the constructor is used, automatically attempt to retrieve a proper
 	 * ContentGenerator based on the Binding given.  The ContentGenerator may
 	 * be replaced by calling setContentGenerator(ContentGenerator).
 	 */
 	public BindingGenerator(Definition definition, Binding binding) {
 		this.definition = definition;
 		this.binding = binding;
 		contentGenerator = getContentGenerator(binding);
 	}

 	/*
 	 * When the constructor is used, automatically attempt to retrieve a proper
 	 * ContentGenerator based on the namespace given.  The ContentGenerator may
 	 * be replaced by calling setContentGenerator(ContentGenerator).
 	 */
 	public BindingGenerator(Definition definition, Binding binding, String namespace) {
 		this.definition = definition;
 		this.binding = binding;
 		contentGenerator = getContentGenerator(namespace);
 	}

 	public static ContentGenerator getContentGenerator(Binding binding) {
 		if (binding == null) {
 			return null;
 		}
 		/******************************************************
 		 * Find the regeistered Content Generator for the Binding
 		 ******************************************************/
 		// Get BindingContent namespace
 		String namespace = null;
 		List eeList = binding.getEExtensibilityElements();
 		if (eeList.size() > 0) {
 	        ExtensibilityElement ee = (ExtensibilityElement) eeList.get(0);
 			// TODO: QName qName = ee.getElementType(); go get the namespace instead?
 	        namespace = ee.getElement().getNamespaceURI();
 			return getContentGenerator(namespace);
 		}

 		return null;
 	}

 	public static ContentGenerator getContentGenerator(String namespace) {
 		ContentGenerator contentGen = null;
 		if (namespace != null) {
 			ContentGeneratorExtensionFactoryRegistry factoryRegistry = ContentGeneratorExtensionFactoryRegistry.getInstance();
 			contentGen = factoryRegistry.getGeneratorClassFromNamespace(namespace);
 		}

 		return contentGen;
 	}

 	private Binding createEmptyBinding(String localName) {
 		String name = localName;
 		if (localName == null) {
 			name = "";
 		}
 	    Binding newBinding = WSDLFactory.eINSTANCE.createBinding();
 		newBinding.setQName(new QName(definition.getTargetNamespace(),localName));
 		newBinding.setEnclosingDefinition(definition);
 	    definition.addBinding(newBinding);

 		return newBinding;
 	}

 	/*
 	 * TODO: Scenario:
 	 * 1)overwrite == false
 	 * 2)BindingOperation with 1 input
 	 * 3)Corresponding Operation (with same name) with 1 input and 1 output
 	 * If we generate with overwrite == false, nothing is done.  Thus,  an
 	 * output is not generated on the BindingOperation.  This is because we
 	 * search for existing Elements only at the level of BindingOperations.
 	 * For example, if there is a corresponding BindingOperation with the same
 	 * name as our Operation, leave it alone.... but since there is already
 	 * a BindingOperation with the same name, we don't create a new BindingOperation.
 	 *
 	 * The correct implementation is reduce this granularity to the MessageReference
 	 * level.  The code is almost there except for how we generate the Binding element
 	 * content.  Look at BindingGenrator.generateBindingOperation() and
 	 * SOAPContentGenerator.java and it's content generation method
 	 * for a good place to start.
 	 *
 	 * For wtp RC1, We shall only look at the Operation level (as we do in the previous
 	 * version).
 	 */
 	public Binding generateBinding() {
 		try {
 		// If Binding is null (No Binding was passed into the constructor), we create an empty Binding first.
 		if (binding == null) {
 			binding = createEmptyBinding(getName());
 		}
 		if (getName() != null && !binding.getQName().getLocalPart().equals(getName())) {
 			binding.setQName(new QName(binding.getQName().getNamespaceURI(), getName()));
 		}
 		if (getRefName() != null) {
 			PortType portType = getPortType();
 			binding.setEPortType(portType);
 			if (portType == null) {
 				//The model doesn't reconile with it's Element properly when we're setting a null for it's PortType
 				binding.getElement().setAttribute("type", "");
 			}
 		}

 		List bindingOperations = binding.getEBindingOperations();
 		PortType portType = binding.getEPortType();

 		if (!getOverwrite()) {
 			// Don't Overwrite
 			if (portType == null) {
 				return binding;
 			}
 			else {
 				addRequiredNamespaces(binding);
 				List operations = portType.getOperations();

 				/*******************************************************************************
 				 * Determine which Operations require new a new corresponding BindingOperations
 				 *******************************************************************************/
 				List newBindingOpsNeeded = new ArrayList();
 				for (int index = 0; index < operations.size(); index++) {
 					Operation operation = (Operation) operations.get(index);

 					boolean foundMatch = false;
 					Iterator bindingOperationsIt = bindingOperations.iterator();
 					while (bindingOperationsIt.hasNext()) {
 						BindingOperation bindingOperation = (BindingOperation) bindingOperationsIt.next();

 						if (namesEqual(bindingOperation.getName(), operation.getName())) {
 							foundMatch = true;
 							break;
 						}
 					}

 					if (!foundMatch){
 						newBindingOpsNeeded.add(operation);
 					}
 				}
 				// newBindingOpsNeeded is the List of Operations needing new corresponding
 				// BindingOperation's
 				List newBindingOps = createNewBindingOperations(newBindingOpsNeeded);

 				// Generate the contents of the new BindingOperation's
 				Iterator newBindingOpsIt = newBindingOps.iterator();
 				while (newBindingOpsIt.hasNext()) {
 					BindingOperation newBindingOp = (BindingOperation) newBindingOpsIt.next();
 					generateBindingOperation(newBindingOp);
 					generateBindingOperationContent(newBindingOp);
 				}
 			}

 			generateBindingContent(binding);
 		}
 		else {
 			// Overwrite
 			if (portType == null) {
 				// We need to blow away everything under the Binding.  No PortType associated with this Binding
 				bindingOperations.clear();
 				return binding;
 			}
 			else {
 				addRequiredNamespaces(binding);
 				List operations = portType.getOperations();

 				/******************************************************
 				 * Compare the Operations
 				 ******************************************************/
 				// Remove any BindingOperations which are no longer used
 				for (int index = 0; index < bindingOperations.size(); index++) {
 					BindingOperation bindingOperation = (BindingOperation) bindingOperations.get(index);

 					boolean foundMatch = false;
 					Iterator operationsIt = operations.iterator();
 					while (operationsIt.hasNext()) {
 						Operation operation = (Operation) operationsIt.next();

 						if (namesEqual(bindingOperation.getName(), operation.getName())) {
 							foundMatch = true;
 							break;
 						}
 					}

 					if (!foundMatch){
 						// We need to remove this BindingFault from the bindingFaults List
 						bindingOperations.remove(index);
 						index--;
 					}
 				}

 				// Remove any Operations which already exists in bindingOperations.  What we
 				// have left are the Operations which needs newly created BindingOperations
 				List bindingOperationsNeeded = new ArrayList();
 				for (int index = 0; index < operations.size(); index++) {
 					Operation operation = (Operation) operations.get(index);

 					boolean foundMatch = false;
 					Iterator bindingOperationsIt = bindingOperations.iterator();
 					while (bindingOperationsIt.hasNext()) {
 						BindingOperation bindingOperation = (BindingOperation) bindingOperationsIt.next();

 						if (namesEqual(bindingOperation.getName(), operation.getName())) {
 							foundMatch = true;
 							break;
 						}
 					}

 					if (!foundMatch){
 						// We need to remove this BindingFault from the bindingFaults List
 						bindingOperationsNeeded.add(operation); // Store the actual Operation
 					}
 				}

 				// Create required BindingOperations
 				createNewBindingOperations(bindingOperationsNeeded);

 				/******************************************************
 				 * Process the contents of the Operations
 				 ******************************************************/
 				Iterator bindingOperationsIt = binding.getEBindingOperations().iterator();
 				while (bindingOperationsIt.hasNext()) {
 					generateBindingOperation((BindingOperation) bindingOperationsIt.next());
 				}

 				generateBindingContent(binding);

 				return binding;
 			}
 		}
 		}
 		catch (Exception e) {
 			e.printStackTrace();
 		}
 		return null;
 	}

 	private List createNewBindingOperations(List operations) {
 		List newBindingOps = new ArrayList();

 		Iterator neededBindingOperationsIt = operations.iterator();
 		while (neededBindingOperationsIt.hasNext()) {
 			Operation operation = (Operation) neededBindingOperationsIt.next();
 			BindingOperation newBindingOperation = factory.createBindingOperation();
 			newBindingOperation.setEOperation(operation);
 			newBindingOperation.setName(operation.getName());
 			binding.addBindingOperation(newBindingOperation);

 			newBindingOps.add(newBindingOperation);
 		}

 		return newBindingOps;
 	}

 	private void generateBindingOperation(BindingOperation bindingOperation) {
 		BindingInput bindingInput = bindingOperation.getEBindingInput();
 		BindingOutput bindingOutput = bindingOperation.getEBindingOutput();
 		List bindingFaults = bindingOperation.getEBindingFaults();

 		Operation operation = bindingOperation.getEOperation();
 		Input input = operation.getEInput();
 		Output output = operation.getEOutput();
 		List faults = operation.getEFaults();

 		/******************************************************
 		 * Compare the Operation names
 		 ******************************************************/
 		if (!namesEqual(bindingOperation.getName(), operation.getName())) {
 			bindingOperation.setName(operation.getName());
 		}


 		/******************************************************
 		 * Compare the Output
 		 ******************************************************/
 		if (output == null) {
 			bindingOperation.setBindingOutput(null);
 		}
 		else {
 			// Create BindingOutput if necessary
 			if (bindingOutput == null) {
 				BindingOutput newBindingOutput = factory.createBindingOutput();
 				newBindingOutput.setEOutput(output);
 				newBindingOutput.setName(output.getName());
 				bindingOperation.setBindingOutput(newBindingOutput);
 			}
 			else {
 				// Compare the Output names
 				if (!namesEqual(bindingOutput.getName(), output.getName())) {
 					bindingOutput.setName(output.getName());
 				}
 			}
 		}
 		generateBindingOutputContent(bindingOperation.getEBindingOutput());

 		/******************************************************
 		 * Compare the Input
 		 ******************************************************/
 		if (input == null) {
 			bindingOperation.setBindingInput(null);
 		}
 		else {
 			// Create BindingInput if necessary
 			if (bindingInput == null) {
 				BindingInput newBindingInput = factory.createBindingInput();
 				newBindingInput.setEInput(input);
 				newBindingInput.setName(input.getName());
 				bindingOperation.setBindingInput(newBindingInput);
 			}
 			else {
 				// Compare the Input names
 				if (!namesEqual(bindingInput.getName(), input.getName())) {
 					bindingInput.setName(input.getName());
 				}
 			}
 		}
 		generateBindingInputContent(bindingOperation.getEBindingInput());


 		/******************************************************
 		 * Compare the Faults
 		 ******************************************************/
 		// Remove any BindingFaults which are no longer used
 		for (int index = 0; index < bindingFaults.size(); index++) {
 			BindingFault bindingFault = (BindingFault) bindingFaults.get(index);

 			boolean foundMatch = false;
 			Iterator faultsIt = faults.iterator();
 			while (faultsIt.hasNext()) {
 				Fault fault = (Fault) faultsIt.next();
 				if (namesEqual(bindingFault.getName(), fault.getName())) {
 					foundMatch = true;
 					break;
 				}
 			}

 			if (!foundMatch){
 				// We need to remove this BindingFault from the bindingFaults List
 				bindingFaults.remove(index);
 				index--;
 			}
 		}

 		// Remove any Faults which already exists in bindingFaults.  What we
 		// have left are the Faults which needs newly created BindingFaults
 		List bindingFaultsNeeded = new ArrayList();
 		for (int index = 0; index < faults.size(); index++) {
 			Fault fault = (Fault) faults.get(index);

 			boolean foundMatch = false;
 			Iterator bindingFaultsIt = bindingFaults.iterator();
 			while (bindingFaultsIt.hasNext()) {
 				BindingFault bindingFault = (BindingFault) bindingFaultsIt.next();
 				if (namesEqual(bindingFault.getName(), fault.getName())) {
 					foundMatch = true;
 					break;
 				}
 			}

 			if (!foundMatch){
 				// We need to remove this BindingFault from the bindingFaults List
 				bindingFaultsNeeded.add(fault);
 			}
 		}

 		// bindingFaultsNeeded contains the needed BindingFault's we need to create
 		Iterator neededBindingFaultsIt = bindingFaultsNeeded.iterator();
 		while (neededBindingFaultsIt.hasNext()) {
 			Fault fault = (Fault) neededBindingFaultsIt.next();
 			BindingFault newBindingFault = factory.createBindingFault();
 			newBindingFault.setEFault(fault);
 			newBindingFault.setName(fault.getName());
 			bindingOperation.addBindingFault(newBindingFault);
 		}

 		// Create the contents for each BindingFault
 		Iterator faultContentIt = bindingOperation.getEBindingFaults().iterator();
 		while (faultContentIt.hasNext()) {
 			BindingFault bindingFault = (BindingFault) faultContentIt.next();
 			generateBindingFaultContent(bindingFault);
 		}

 		generateBindingOperationContent(bindingOperation);
 	}

 	private boolean namesEqual(String name1, String name2) {
 		boolean match = false;

 		if (name1 != null ^ name2 != null) {
 			// one is null
 			match = false;
 		}
 		else if (name1 != null && name2 != null) {
 			// neither is null
 			match = name1.equals(name2);
 		}
 		else {
 			// both are null
 			match = true;
 		}

 		return match;
 	}

 	protected void generateBindingContent(Binding binding) {
 		if (contentGenerator != null) {
 			if (binding.getEExtensibilityElements().size() == 0) {
 				contentGenerator.generateBindingContent(binding, (PortType) binding.getEPortType());
 			}
 		}
 		else {
 			removeExtensibilityElements(binding);
 		}
 	}

 	protected void generateBindingOperationContent(BindingOperation bindingOperation) {
 		if (bindingOperation != null && contentGenerator != null) {
 			contentGenerator.generateBindingOperationContent(bindingOperation, bindingOperation.getEOperation());
 		}
 		else {
 			removeExtensibilityElements(bindingOperation);
 		}
 	}

 	protected void generateBindingInputContent(BindingInput bindingInput) {
 		if (bindingInput != null && contentGenerator != null) {
 			contentGenerator.generateBindingInputContent(bindingInput, bindingInput.getEInput());
 		}
 		else {
 			removeExtensibilityElements(bindingInput);
 		}
 	}

 	protected void generateBindingOutputContent(BindingOutput bindingOutput) {
 		if (bindingOutput != null && contentGenerator != null) {
 			contentGenerator.generateBindingOutputContent(bindingOutput, bindingOutput.getEOutput());
 		}
 		else {
 			removeExtensibilityElements(bindingOutput);
 		}
 	}

 	protected void generateBindingFaultContent(BindingFault bindingFault) {
 		if (bindingFault != null && contentGenerator != null) {
 			contentGenerator.generateBindingFaultContent(bindingFault, bindingFault.getEFault());
 		}
 		else {
 			removeExtensibilityElements(bindingFault);
 		}
 	}

 	private void removeExtensibilityElements(ExtensibleElement ee) {
 		if (ee != null) {
 			ee.getEExtensibilityElements().clear();
 		}
 	}

 	/*
 	 * Generate Port Content for all Ports with a reference to the Binding
 	 * which was passed in through the constructor (or a reference to the
 	 * newly created Binding).
 	 */
 	public void generatePortContent() {
 		if (binding != null && contentGenerator != null) {
 			List portsToUpdate = new ArrayList();

 			Iterator servicesIt = binding.getEnclosingDefinition().getEServices().iterator();
 			while (servicesIt.hasNext()) {
 				Service service = (Service) servicesIt.next();
 				Iterator portsIt = service.getEPorts().iterator();
 				while (portsIt.hasNext()) {
 					Port port = (Port) portsIt.next();
 					if (binding.equals(port.getEBinding())) {
 						// Found a match
 						portsToUpdate.add(port);
 					}
 				}
 			}

 			Iterator portsToUpdateIt = portsToUpdate.iterator();
 			while (portsToUpdateIt.hasNext()) {
 				contentGenerator.generatePortContent((Port) portsToUpdateIt.next());
 			}
 		}
 	}

 	/*
 	 * methods addRequiredNamespaces() and computeUniquePrefix() are used to add necessary
 	 * namespaces
 	 *
 	 * TODO:
 	 * Does this belong here?  This is copied from wsdl.ui.  Can we sync up in some way?
 	 */
 	protected void addRequiredNamespaces(Binding binding) {
 		if (contentGenerator != null) {
 			String[] namespaceNames = contentGenerator.getRequiredNamespaces();
 			String[] preferredPrefixes = new String[namespaceNames.length];
 			for (int index = 0; index < namespaceNames.length; index++) {
 				preferredPrefixes[index] = contentGenerator.getPreferredNamespacePrefix(namespaceNames[index]);
 			}

 			Map map = binding.getEnclosingDefinition().getNamespaces();

 		      for (int i = 0; i < namespaceNames.length; i++) {
 		        String namespace = namespaceNames[i];
 		        if (!map.containsValue(namespace)) {
 		          String prefix = (i < preferredPrefixes.length) ? preferredPrefixes[i] : "p0";
 		          if (map.containsKey(prefix)) {
 		            prefix = computeUniquePrefix("p", map);
 		          }
 				  binding.getEnclosingDefinition().addNamespace(prefix, namespace);
 		        }
 		      }
 		}
 	}

 	private String computeUniquePrefix(String base, Map table){
 	    int i = 0;
 	    String prefix = base;
 	    while (true) {
 	      if (!table.containsKey(prefix)) {
 	        break;
 	      }
 	      else {
 	        prefix = base + i;
 	        i++;
 	      }
 	    }
 	    return prefix;
 	}

 	private PortType getPortType() {
 		if (getRefName().equals("")) {
 			// Means we should set the PortType to Unspecified
 			return null;
 		}

 		if (getRefName() != null) {
 			Iterator portTypeIt = definition.getEPortTypes().iterator();

 			while (portTypeIt.hasNext()) {
 				PortType pt = (PortType) portTypeIt.next();
 				List prefixedNames = getPrefixedNames(pt);
 				if (prefixedNames.contains(getRefName())) {
 					return pt;
 				}
 			}
 		}

 		return binding.getEPortType();
 	}

 	private List getPrefixedNames(PortType portType) {
 		List prefixedNames = new ArrayList();
 		String currentPortTypeName = portType.getQName().getLocalPart();
 		String currentNamespace = portType.getQName().getNamespaceURI();

 		Map namespaceMap = definition.getNamespaces();
 		Iterator keys = namespaceMap.keySet().iterator();
 		while (keys.hasNext()) {
 			Object key = keys.next();
 			Object value = namespaceMap.get(key);

 			if (currentNamespace.equals(value)) {
 				// Found a match.  Add to our list
 				prefixedNames.add(key + ":" + currentPortTypeName);
 			}
 		}

 		return prefixedNames;

 	}
 }
	package org.eclipse.wst.wsdl.internal.generator;

	import java.util.ArrayList;
	import java.util.Iterator;
	import java.util.List;
	import java.util.Map;

	import javax.xml.namespace.QName;

	import org.eclipse.wst.wsdl.Binding;
	import org.eclipse.wst.wsdl.BindingFault;
	import org.eclipse.wst.wsdl.BindingInput;
	import org.eclipse.wst.wsdl.BindingOperation;
	import org.eclipse.wst.wsdl.BindingOutput;
	import org.eclipse.wst.wsdl.Definition;
	import org.eclipse.wst.wsdl.ExtensibilityElement;
	import org.eclipse.wst.wsdl.ExtensibleElement;
	import org.eclipse.wst.wsdl.Fault;
	import org.eclipse.wst.wsdl.Input;
	import org.eclipse.wst.wsdl.Operation;
	import org.eclipse.wst.wsdl.Output;
	import org.eclipse.wst.wsdl.Port;
	import org.eclipse.wst.wsdl.PortType;
	import org.eclipse.wst.wsdl.Service;
	import org.eclipse.wst.wsdl.WSDLFactory;
	import org.eclipse.wst.wsdl.internal.generator.extension.ContentGeneratorExtensionFactoryRegistry;

	/*
	* Class used to generate the Binding and it's content. We look in the registry for
	* appropriate ContentGenerator classes based on the existing Binding Content's namespace.
	* Alternatively, users can pass in a namespace through the constructor to specify which
	* namespace to use when searching the registry.
	*
	* The ContentGenerator may also be set manually by calling
	* setContentGenerator(ContentGenerator).
	*/
	public class BindingGenerator extends BaseGenerator {
	private WSDLFactory factory = WSDLFactory.eINSTANCE;
	private Binding binding;

	/*
	* When the constructor is used, automatically attempt to retrieve a proper
	* ContentGenerator based on the Binding given. The ContentGenerator may
	* be replaced by calling setContentGenerator(ContentGenerator).
	*/
	public BindingGenerator(Definition definition, Binding binding) {
	this.definition = definition;
	this.binding = binding;
	contentGenerator = getContentGenerator(binding);
	}

	/*
	* When the constructor is used, automatically attempt to retrieve a proper
	* ContentGenerator based on the namespace given. The ContentGenerator may
	* be replaced by calling setContentGenerator(ContentGenerator).
	*/
	public BindingGenerator(Definition definition, Binding binding, String namespace) {
	this.definition = definition;
	this.binding = binding;
	contentGenerator = getContentGenerator(namespace);
	}

	public static ContentGenerator getContentGenerator(Binding binding) {
	if (binding == null) {
	return null;
	}
	/******************************************************
	* Find the regeistered Content Generator for the Binding
	******************************************************/
	// Get BindingContent namespace
	String namespace = null;
	List eeList = binding.getEExtensibilityElements();
	if (eeList.size() > 0) {
	ExtensibilityElement ee = (ExtensibilityElement) eeList.get(0);
	// TODO: QName qName = ee.getElementType(); go get the namespace instead?
	namespace = ee.getElement().getNamespaceURI();
	return getContentGenerator(namespace);
	}

	return null;
	}

	public static ContentGenerator getContentGenerator(String namespace) {
	ContentGenerator contentGen = null;
	if (namespace != null) {
	ContentGeneratorExtensionFactoryRegistry factoryRegistry = ContentGeneratorExtensionFactoryRegistry.getInstance();
	contentGen = factoryRegistry.getGeneratorClassFromNamespace(namespace);
	}

	return contentGen;
	}

	private Binding createEmptyBinding(String localName) {
	String name = localName;
	if (localName == null) {
	name = "";
	}
	Binding newBinding = WSDLFactory.eINSTANCE.createBinding();
	newBinding.setQName(new QName(definition.getTargetNamespace(),localName));
	newBinding.setEnclosingDefinition(definition);
	definition.addBinding(newBinding);

	return newBinding;
	}

	/*
	* TODO: Scenario:
	* 1)overwrite == false
	* 2)BindingOperation with 1 input
	* 3)Corresponding Operation (with same name) with 1 input and 1 output
	* If we generate with overwrite == false, nothing is done. Thus, an
	* output is not generated on the BindingOperation. This is because we
	* search for existing Elements only at the level of BindingOperations.
	* For example, if there is a corresponding BindingOperation with the same
	* name as our Operation, leave it alone.... but since there is already
	* a BindingOperation with the same name, we don't create a new BindingOperation.
	*
	* The correct implementation is reduce this granularity to the MessageReference
	* level. The code is almost there except for how we generate the Binding element
	* content. Look at BindingGenrator.generateBindingOperation() and
	* SOAPContentGenerator.java and it's content generation method
	* for a good place to start.
	*
	* For wtp RC1, We shall only look at the Operation level (as we do in the previous
	* version).
	*/
	public Binding generateBinding() {
	try {
	// If Binding is null (No Binding was passed into the constructor), we create an empty Binding first.
	if (binding == null) {
	binding = createEmptyBinding(getName());
	}
	if (getName() != null && !binding.getQName().getLocalPart().equals(getName())) {
	binding.setQName(new QName(binding.getQName().getNamespaceURI(), getName()));
	}
	if (getRefName() != null) {
	PortType portType = getPortType();
	binding.setEPortType(portType);
	if (portType == null) {
	//The model doesn't reconile with it's Element properly when we're setting a null for it's PortType
	binding.getElement().setAttribute("type", "");
	}
	}

	List bindingOperations = binding.getEBindingOperations();
	PortType portType = binding.getEPortType();

	if (!getOverwrite()) {
	// Don't Overwrite
	if (portType == null) {
	return binding;
	}
	else {
	addRequiredNamespaces(binding);
	List operations = portType.getOperations();

	/*******************************************************************************
	* Determine which Operations require new a new corresponding BindingOperations
	*******************************************************************************/
	List newBindingOpsNeeded = new ArrayList();
	for (int index = 0; index < operations.size(); index++) {
	Operation operation = (Operation) operations.get(index);

	boolean foundMatch = false;
	Iterator bindingOperationsIt = bindingOperations.iterator();
	while (bindingOperationsIt.hasNext()) {
	BindingOperation bindingOperation = (BindingOperation) bindingOperationsIt.next();

	if (namesEqual(bindingOperation.getName(), operation.getName())) {
	foundMatch = true;
	break;
	}
	}

	if (!foundMatch){
	newBindingOpsNeeded.add(operation);
	}
	}
	// newBindingOpsNeeded is the List of Operations needing new corresponding
	// BindingOperation's
	List newBindingOps = createNewBindingOperations(newBindingOpsNeeded);

	// Generate the contents of the new BindingOperation's
	Iterator newBindingOpsIt = newBindingOps.iterator();
	while (newBindingOpsIt.hasNext()) {
	BindingOperation newBindingOp = (BindingOperation) newBindingOpsIt.next();
	generateBindingOperation(newBindingOp);
	generateBindingOperationContent(newBindingOp);
	}
	}

	generateBindingContent(binding);
	}
	else {
	// Overwrite
	if (portType == null) {
	// We need to blow away everything under the Binding. No PortType associated with this Binding
	bindingOperations.clear();
	return binding;
	}
	else {
	addRequiredNamespaces(binding);
	List operations = portType.getOperations();

	/******************************************************
	* Compare the Operations
	******************************************************/
	// Remove any BindingOperations which are no longer used
	for (int index = 0; index < bindingOperations.size(); index++) {
	BindingOperation bindingOperation = (BindingOperation) bindingOperations.get(index);

	boolean foundMatch = false;
	Iterator operationsIt = operations.iterator();
	while (operationsIt.hasNext()) {
	Operation operation = (Operation) operationsIt.next();

	if (namesEqual(bindingOperation.getName(), operation.getName())) {
	foundMatch = true;
	break;
	}
	}

	if (!foundMatch){
	// We need to remove this BindingFault from the bindingFaults List
	bindingOperations.remove(index);
	index--;
	}
	}

	// Remove any Operations which already exists in bindingOperations. What we
	// have left are the Operations which needs newly created BindingOperations
	List bindingOperationsNeeded = new ArrayList();
	for (int index = 0; index < operations.size(); index++) {
	Operation operation = (Operation) operations.get(index);

	boolean foundMatch = false;
	Iterator bindingOperationsIt = bindingOperations.iterator();
	while (bindingOperationsIt.hasNext()) {
	BindingOperation bindingOperation = (BindingOperation) bindingOperationsIt.next();

	if (namesEqual(bindingOperation.getName(), operation.getName())) {
	foundMatch = true;
	break;
	}
	}

	if (!foundMatch){
	// We need to remove this BindingFault from the bindingFaults List
	bindingOperationsNeeded.add(operation); // Store the actual Operation
	}
	}

	// Create required BindingOperations
	createNewBindingOperations(bindingOperationsNeeded);

	/******************************************************
	* Process the contents of the Operations
	******************************************************/
	Iterator bindingOperationsIt = binding.getEBindingOperations().iterator();
	while (bindingOperationsIt.hasNext()) {
	generateBindingOperation((BindingOperation) bindingOperationsIt.next());
	}

	generateBindingContent(binding);

	return binding;
	}
	}
	}
	catch (Exception e) {
	e.printStackTrace();
	}
	return null;
	}

	private List createNewBindingOperations(List operations) {
	List newBindingOps = new ArrayList();

	Iterator neededBindingOperationsIt = operations.iterator();
	while (neededBindingOperationsIt.hasNext()) {
	Operation operation = (Operation) neededBindingOperationsIt.next();
	BindingOperation newBindingOperation = factory.createBindingOperation();
	newBindingOperation.setEOperation(operation);
	newBindingOperation.setName(operation.getName());
	binding.addBindingOperation(newBindingOperation);

	newBindingOps.add(newBindingOperation);
	}

	return newBindingOps;
	}

	private void generateBindingOperation(BindingOperation bindingOperation) {
	BindingInput bindingInput = bindingOperation.getEBindingInput();
	BindingOutput bindingOutput = bindingOperation.getEBindingOutput();
	List bindingFaults = bindingOperation.getEBindingFaults();

	Operation operation = bindingOperation.getEOperation();
	Input input = operation.getEInput();
	Output output = operation.getEOutput();
	List faults = operation.getEFaults();

	/******************************************************
	* Compare the Operation names
	******************************************************/
	if (!namesEqual(bindingOperation.getName(), operation.getName())) {
	bindingOperation.setName(operation.getName());
	}


	/******************************************************
	* Compare the Output
	******************************************************/
	if (output == null) {
	bindingOperation.setBindingOutput(null);
	}
	else {
	// Create BindingOutput if necessary
	if (bindingOutput == null) {
	BindingOutput newBindingOutput = factory.createBindingOutput();
	newBindingOutput.setEOutput(output);
	newBindingOutput.setName(output.getName());
	bindingOperation.setBindingOutput(newBindingOutput);
	}
	else {
	// Compare the Output names
	if (!namesEqual(bindingOutput.getName(), output.getName())) {
	bindingOutput.setName(output.getName());
	}
	}
	}
	generateBindingOutputContent(bindingOperation.getEBindingOutput());

	/******************************************************
	* Compare the Input
	******************************************************/
	if (input == null) {
	bindingOperation.setBindingInput(null);
	}
	else {
	// Create BindingInput if necessary
	if (bindingInput == null) {
	BindingInput newBindingInput = factory.createBindingInput();
	newBindingInput.setEInput(input);
	newBindingInput.setName(input.getName());
	bindingOperation.setBindingInput(newBindingInput);
	}
	else {
	// Compare the Input names
	if (!namesEqual(bindingInput.getName(), input.getName())) {
	bindingInput.setName(input.getName());
	}
	}
	}
	generateBindingInputContent(bindingOperation.getEBindingInput());


	/******************************************************
	* Compare the Faults
	******************************************************/
	// Remove any BindingFaults which are no longer used
	for (int index = 0; index < bindingFaults.size(); index++) {
	BindingFault bindingFault = (BindingFault) bindingFaults.get(index);

	boolean foundMatch = false;
	Iterator faultsIt = faults.iterator();
	while (faultsIt.hasNext()) {
	Fault fault = (Fault) faultsIt.next();
	if (namesEqual(bindingFault.getName(), fault.getName())) {
	foundMatch = true;
	break;
	}
	}

	if (!foundMatch){
	// We need to remove this BindingFault from the bindingFaults List
	bindingFaults.remove(index);
	index--;
	}
	}

	// Remove any Faults which already exists in bindingFaults. What we
	// have left are the Faults which needs newly created BindingFaults
	List bindingFaultsNeeded = new ArrayList();
	for (int index = 0; index < faults.size(); index++) {
	Fault fault = (Fault) faults.get(index);

	boolean foundMatch = false;
	Iterator bindingFaultsIt = bindingFaults.iterator();
	while (bindingFaultsIt.hasNext()) {
	BindingFault bindingFault = (BindingFault) bindingFaultsIt.next();
	if (namesEqual(bindingFault.getName(), fault.getName())) {
	foundMatch = true;
	break;
	}
	}

	if (!foundMatch){
	// We need to remove this BindingFault from the bindingFaults List
	bindingFaultsNeeded.add(fault);
	}
	}

	// bindingFaultsNeeded contains the needed BindingFault's we need to create
	Iterator neededBindingFaultsIt = bindingFaultsNeeded.iterator();
	while (neededBindingFaultsIt.hasNext()) {
	Fault fault = (Fault) neededBindingFaultsIt.next();
	BindingFault newBindingFault = factory.createBindingFault();
	newBindingFault.setEFault(fault);
	newBindingFault.setName(fault.getName());
	bindingOperation.addBindingFault(newBindingFault);
	}

	// Create the contents for each BindingFault
	Iterator faultContentIt = bindingOperation.getEBindingFaults().iterator();
	while (faultContentIt.hasNext()) {
	BindingFault bindingFault = (BindingFault) faultContentIt.next();
	generateBindingFaultContent(bindingFault);
	}

	generateBindingOperationContent(bindingOperation);
	}

	private boolean namesEqual(String name1, String name2) {
	boolean match = false;

	if (name1 != null ^ name2 != null) {
	// one is null
	match = false;
	}
	else if (name1 != null && name2 != null) {
	// neither is null
	match = name1.equals(name2);
	}
	else {
	// both are null
	match = true;
	}

	return match;
	}

	protected void generateBindingContent(Binding binding) {
	if (contentGenerator != null) {
	if (binding.getEExtensibilityElements().size() == 0) {
	contentGenerator.generateBindingContent(binding, (PortType) binding.getEPortType());
	}
	}
	else {
	removeExtensibilityElements(binding);
	}
	}

	protected void generateBindingOperationContent(BindingOperation bindingOperation) {
	if (bindingOperation != null && contentGenerator != null) {
	contentGenerator.generateBindingOperationContent(bindingOperation, bindingOperation.getEOperation());
	}
	else {
	removeExtensibilityElements(bindingOperation);
	}
	}

	protected void generateBindingInputContent(BindingInput bindingInput) {
	if (bindingInput != null && contentGenerator != null) {
	contentGenerator.generateBindingInputContent(bindingInput, bindingInput.getEInput());
	}
	else {
	removeExtensibilityElements(bindingInput);
	}
	}

	protected void generateBindingOutputContent(BindingOutput bindingOutput) {
	if (bindingOutput != null && contentGenerator != null) {
	contentGenerator.generateBindingOutputContent(bindingOutput, bindingOutput.getEOutput());
	}
	else {
	removeExtensibilityElements(bindingOutput);
	}
	}

	protected void generateBindingFaultContent(BindingFault bindingFault) {
	if (bindingFault != null && contentGenerator != null) {
	contentGenerator.generateBindingFaultContent(bindingFault, bindingFault.getEFault());
	}
	else {
	removeExtensibilityElements(bindingFault);
	}
	}

	private void removeExtensibilityElements(ExtensibleElement ee) {
	if (ee != null) {
	ee.getEExtensibilityElements().clear();
	}
	}

	/*
	* Generate Port Content for all Ports with a reference to the Binding
	* which was passed in through the constructor (or a reference to the
	* newly created Binding).
	*/
	public void generatePortContent() {
	if (binding != null && contentGenerator != null) {
	List portsToUpdate = new ArrayList();

	Iterator servicesIt = binding.getEnclosingDefinition().getEServices().iterator();
	while (servicesIt.hasNext()) {
	Service service = (Service) servicesIt.next();
	Iterator portsIt = service.getEPorts().iterator();
	while (portsIt.hasNext()) {
	Port port = (Port) portsIt.next();
	if (binding.equals(port.getEBinding())) {
	// Found a match
	portsToUpdate.add(port);
	}
	}
	}

	Iterator portsToUpdateIt = portsToUpdate.iterator();
	while (portsToUpdateIt.hasNext()) {
	contentGenerator.generatePortContent((Port) portsToUpdateIt.next());
	}
	}
	}

	/*
	* methods addRequiredNamespaces() and computeUniquePrefix() are used to add necessary
	* namespaces
	*
	* TODO:
	* Does this belong here? This is copied from wsdl.ui. Can we sync up in some way?
	*/
	protected void addRequiredNamespaces(Binding binding) {
	if (contentGenerator != null) {
	String[] namespaceNames = contentGenerator.getRequiredNamespaces();
	String[] preferredPrefixes = new String[namespaceNames.length];
	for (int index = 0; index < namespaceNames.length; index++) {
	preferredPrefixes[index] = contentGenerator.getPreferredNamespacePrefix(namespaceNames[index]);
	}

	Map map = binding.getEnclosingDefinition().getNamespaces();

	for (int i = 0; i < namespaceNames.length; i++) {
	String namespace = namespaceNames[i];
	if (!map.containsValue(namespace)) {
	String prefix = (i < preferredPrefixes.length) ? preferredPrefixes[i] : "p0";
	if (map.containsKey(prefix)) {
	prefix = computeUniquePrefix("p", map);
	}
	binding.getEnclosingDefinition().addNamespace(prefix, namespace);
	}
	}
	}
	}

	private String computeUniquePrefix(String base, Map table){
	int i = 0;
	String prefix = base;
	while (true) {
	if (!table.containsKey(prefix)) {
	break;
	}
	else {
	prefix = base + i;
	i++;
	}
	}
	return prefix;
	}

	private PortType getPortType() {
	if (getRefName().equals("")) {
	// Means we should set the PortType to Unspecified
	return null;
	}

	if (getRefName() != null) {
	Iterator portTypeIt = definition.getEPortTypes().iterator();

	while (portTypeIt.hasNext()) {
	PortType pt = (PortType) portTypeIt.next();
	List prefixedNames = getPrefixedNames(pt);
	if (prefixedNames.contains(getRefName())) {
	return pt;
	}
	}
	}

	return binding.getEPortType();
	}

	private List getPrefixedNames(PortType portType) {
	List prefixedNames = new ArrayList();
	String currentPortTypeName = portType.getQName().getLocalPart();
	String currentNamespace = portType.getQName().getNamespaceURI();

	Map namespaceMap = definition.getNamespaces();
	Iterator keys = namespaceMap.keySet().iterator();
	while (keys.hasNext()) {
	Object key = keys.next();
	Object value = namespaceMap.get(key);

	if (currentNamespace.equals(value)) {
	// Found a match. Add to our list
	prefixedNames.add(key + ":" + currentPortTypeName);
	}
	}

	return prefixedNames;

	}
	}