wsdlcpp.java

linux下开发的soap协议。建议大家学习学习！

				//System.out.println("Structure "+currentNS+

				//getAttrValue(complexNode,"name")+" { ");
				String description;

				/*System.out.println("struct "+dataType(arrayName)+" { ");*/
				int dim = getArrayDimension(arrayType);
				
				String type = arrayType.substring(0,arrayType.indexOf('['));
				
				if(dim==1)
				    {
					/*System.out.println("struct "+dataType(type)
					  +"\t*__ptr;\nint\t__size;\nint\t__offset;\n};");*/
					if(xsdflag)
					    description =dataType(type)+"\t*__ptr;\nint\t__size;\nint\t__offset;\n};";
					else
					    description = "struct "+dataType(type)+"\t*__ptr;\nint\t__size;\nint\t__offset;\n};";
				    }
				else
				    {
					/*System.out.println(dataType(type)
							   + "\t*__ptr;\n 
int\t__size["+dim+"];\nint\t__offset["+dim+"]\n};");*/

					if(xsdflag)
					description = dataType(type)+
					       "\t*__ptr;\nint\t__size["+dim+"];\nint\t__offset["+dim+"]\n};";
					else
					    description = "struct "+dataType(type)
					     + "\t*__ptr;\nint\t__size["+dim+"];\nint\t__offset["+dim+"]\n};";
				    }
				
				addDataType("",arrayName,description);
				processedArrays.put(arrayType,arrayName);
			    }
			else
			    {
				/*add in to  TOBE process que*/
				tobeProcessedArrays.put(arrayType,arrayName+"\n"+curlocalXSDNS);
			    }
		    }
		else
		    {

			if(dataName==null)
			    dataName = new String("");
			
			structureNodes.put(ncomplexNode,dataName+"\n"+schemaNS);

			if(dataName.equals(""))
			    dataName = null;

			
		    }
		ncomplexNode = complexType.getNextNode();
		if(ncomplexNode!=null)
		    complexNode = ncomplexNode.getNode();
	    }

	
	
	/*System.out.println("to be processed que is "+tobeProcessedArrays.size());*/

	processPendingArrays();

    }


    private void processAllStructures()
    {


	Enumeration keyList;

	keyList = structureNodes.keys();
	
	while(keyList.hasMoreElements())
	    {

		NsNode ncomplexNode = (NsNode)keyList.nextElement();
		String datasch = (String)structureNodes.get(ncomplexNode);
		
		String dataName = datasch.substring(0,datasch.indexOf('\n'));


		
		String schemaNS = datasch.substring(datasch.indexOf('\n')+1);
		/*get it from hashtable ... put it along with dataname*/

		
		Node complexNode=ncomplexNode.getNode();
		
		String currentNS=getNsEquivalent(ncomplexNode.getNameSpace(),"definitionNS");
		/*		String schemaNS =null;*/
		
		Hashtable referenceNameSpace=null;
	
		String description = new String("");
		String structName =null;



		String occursString = "__size";


		
		

		
		if(dataName.equals(""))
		    structName= getAttrValue(complexNode,"name");
		else
		    structName = dataName;
		
	        //processing for a strucuture
/*		System.out.println("struct "+dataType(currentNS+ structName)+" { ");*/
		
		NsNodeSearch element = new NsNodeSearch(complexNode,schemaNS+"element",ncomplexNode.getNameSpace());
		
		NsNode nelementNode = element.getNextNode();
		
		Node elementNode =null;
		
		if(nelementNode!=null)
		    {
			elementNode =nelementNode.getNode();
			referenceNameSpace = nelementNode.getNameSpace();
		    }
		
		for(int j=0;j<element.getTotalMatches();j++)
		    {
			String typeStr = getAttrValue(elementNode,"type");
			String nameStr = getAttrValue(elementNode,"name");
			
			//System.out.println("Name space "+getNS(typeStr)+typeStr);
			String curlocalXSDNS = getNsEquivalent(referenceNameSpace,"xsdNS");
		
			String ptr=" ";
			
			boolean maxoccursFlag = false;
			
			String nillable = getAttrValue(elementNode,"nillable");

			
			if((nillable!=null)&&(nillable.compareToIgnoreCase("true")==0))
			    {
				ptr="*";
			    }
			

			if(isArrayType(typeStr))
			    {
				typeStr ="struct "+ getName(typeStr);
			    }
			else
			    {
				if(isXsd(typeStr,curlocalXSDNS))
				    typeStr = new String("xsd:"+getName(typeStr));
				else
				    {
					ptr="*";
					typeStr = new String("struct "+typeStr);
				    }
			    }


			
			
			String maxOccurs = getAttrValue(elementNode,"maxOccurs");
			if((maxOccurs!=null)&&(maxOccurs.equals("unbounded")))
			    {
				ptr = "*";
				occursString  +="_";
				maxoccursFlag = true;
			    }

			/*max occurs is unbound*/
			if(maxoccursFlag)
			    {
				description+="int\t"+occursString+";\n";
				/*System.out.println("int\t"+occursString);*/
			    }

			
			
			description+=dataType(typeStr)+ "\t"+ptr+convertToCpp(nameStr,true)+" ;\n";
		
			/*System.out.println(dataType(typeStr)+ "\t"+ptr+convertToCpp(nameStr)+" ;");*/

			
			
			nelementNode = element.getNextNode();
			
			if(nelementNode!=null)
			    {
				elementNode = nelementNode.getNode();
				referenceNameSpace = nelementNode.getNameSpace();
			    }
		    }
		
		description+=" } ;";
/*		System.out.println(" } ;");*/
		
		
		addDataType(currentNS,structName,description);
	    }
    }



    boolean isArrayType(String name)
    {
	if(name==null)
	{    System.out.println("Error occurred while parsing the file\nWSDL file may be encoded using Doc/Literal\nDoc/Literal is not completely supported in this version of WSDL reader");
	System.exit(0);
	}
	    else
	//System.out.println(name);
	if(processedArrays.containsValue(getName(name)))
	    return true;
       
	return false;

    }
    
    private void processPendingArrays()
    {
	Enumeration keyList;

	boolean someProcessed = false;
	
	keyList = tobeProcessedArrays.keys();
	
	while(keyList.hasMoreElements())
	    {
		String arrType = (String)keyList.nextElement();
		

		String temp= (String)tobeProcessedArrays.get(arrType);

		String arrName=temp.substring(0,temp.indexOf('\n'));
		String curlocalXSDNS = temp.substring(temp.indexOf('\n')+1);
		String baseType = arrType.substring(0,arrType.lastIndexOf("["));


		//System.out.println(arrType+"   "+baseType+"  "+arrName);
		
		if(processedArrays.containsKey(baseType))
		    {
			String description;
			
			someProcessed = true;

			String baseName = (String)processedArrays.get(baseType);
			
			/*System.out.println("struct "+dataType(arrName)+" { ");*/
			int dim = getArrayDimension(arrType);

			//String type = arrType.substring(0,arrType.indexOf('['));

			//System.out.println("test basa Name "+baseName);
			String type = baseName;
			if(dim==1)
			    {
				/*	System.out.println("test"+dataType(baseName)
					+ "\t*__ptr;\nint\t__size;\nint\t__offset;\n};");*/
					if(isXsd(type,curlocalXSDNS))
					    description =dataType(type)+"\t*__ptr;\nint\t__size;\nint\t__offset;\n};";
					else
					    description = "struct "+dataType(type)+"\t*__ptr;\nint\t__size;\nint\t__offset;\n};";
					/*
				description = "struct "+dataType(baseName)
				+ "\t*__ptr;\nint\t__size;\nint\t__offset;\n};";*/
			    }
			else
			    {

				if(isXsd(type,curlocalXSDNS))
				    description = dataType(type)+
					"\t*__ptr;\nint\t__size["+dim+"];\nint\t__offset["+dim+"]\n};";
				else
				    description = "struct "+dataType(type)
					+ "\t*__ptr;\nint\t__size["+dim+"];\nint\t__offset["+dim+"]\n};";
				/*System.out.println(dataType(baseName)
				  + "\t*__ptr;\nint\t__size["+dim+"];\nint\t__offset["+dim+"]\n};");*/
				/*				description = "struct "+dataType(baseName)
								+ "\t*__ptr;\nint\t__size["+dim+"];\nint\t__offset["+dim+"]\n};";*/
			    }
			
			addDataType("",arrName,description);
			
			processedArrays.put(arrType,arrName);
			tobeProcessedArrays.remove(arrType);
		    }
	    }
		
		if(someProcessed)
		    {
			if(tobeProcessedArrays.size()!=0)
			    {
				processPendingArrays();
				System.out.println("recall");
			    }
		    }
		else
		    {
			if(tobeProcessedArrays.size()!=0)
			    System.out.println("Warning : some array element left unprocessed and the size of to be processed array is "+tobeProcessedArrays.size());
		    }  
    }


    Hashtable allDataType = new Hashtable();
    
    void addDataType(String cNS,String arrayName, String description)
    {
	boolean inserted = false;
	while(!inserted)
	    {
		if(!allDataType.containsKey(arrayName))
		    {
			allDataType.put(arrayName,"struct "+dataType(cNS+arrayName)+" {\n"+description);
			inserted = true;
		    }
		else
		    {
			if(((String)allDataType.get(arrayName)).compareToIgnoreCase("struct "+dataType(cNS+arrayName)+" {\n"+description)==0)
			    return;
			arrayName = "_"+arrayName;
		    }
	    }
    }
    

    private int getArrayDimension(String atype)
    {
	int lindex = atype.lastIndexOf("[");
	String last = atype.substring(lindex,atype.length());

	int cnt=0;

	int indx=-1;

	while((indx=last.indexOf(',',indx+1))!=-1)cnt++;

	return cnt+1;
    }

    
    private boolean singleLevelArray(String atype)
    {
	int cnt=0;

	int indx=-1;
	while((indx=atype.indexOf('[',indx+1))!=-1)cnt++;
	
	if(cnt==1)
	    return true;
	else
	    return false;
    }
    
    private String getNS(String name)
    {
	
	if(name.indexOf(':')==-1)
	    return "";
	return name.substring(0,name.indexOf(':')+1);
    }
    
    private String getName(String name)
    {
	if(name.indexOf(':')==-1)
	    return name;
	return name.substring(name.indexOf(':')+1);
    }	
	      

public void parseMyDoc(Node node)
    {

	intitlizePrimitiveType();
	
	if(node.getNodeType()!=Node.DOCUMENT_NODE)
	    {
		System.out.println("Expected a Document node!!!!!");
		System.exit(0);
	    }
	NodeList nodes = node.getChildNodes();
	//	node = nodes.item(0);	/* go to a lever below definitions*/
	/*nodes = node.getChildNodes();*/


	if (nodes != null)
	    {
		
		setNameSpaces(node);

		printTypesInformation(node);
		/*		
		System.out.println("********************Name Space Information ***********************");
		System.out.println("Def NS "+definitionNS);
		//System.out.println("WSDL NS "+ wsdlNS);
		//System.out.println("XSD NS "+ xsdNS);
		System.out.println("Doc NS "+ docNS);
		//System.out.println("Encoding NS "+ encodingNS);
		System.out.println("******************** END Name Space Information ******************\n\n");
		*/
		//getServiceInfo(nodes.item(0));

		getServiceInfo(node);
		/*
		System.out.println("********************Service Information***************************");
		System.out.println("Service of the document found - "+ serviceName);
		System.out.println("Port number - "+ servicePortName);
		System.out.println("Binding Name - "+ servicePortBinding);
		System.out.println("Addess location - "+  serviceAddrLocation);


		System.out.println("********************End of Service Information********************\n\n");
		*/
		getBindingInfo(node,servicePortBinding.substring(servicePortBinding.indexOf(":")+1));
		/*		
		System.out.println("Operation -"+operationName);
		System.out.println("Input -"+inputName);
		System.out.println("Output -"+outputName);
		
		String inputParameters = getMessageEquivalent(node,inputName);
		System.out.println("input parameters - "+inputParameters);
		
		String outputParameters = getMessageEquivalent(node,outputName);
		System.out.println("output parameters - "+outputParameters);
		
		*/
		    
	    }
	
    }





    
    public static void main(String[] args) {
        if (args.length != 1) {
            System.out.println("Usage: java wsdlcpp [XML URI]");
            System.exit(0);
        }
        
        String uri = args[0];
    
        wsdlcpp parserParser = new wsdlcpp();
	parserParser.myParser(uri);
	  
    }
    
}