From f3476576c50efd922593c82656efda7aec5ae97f Mon Sep 17 00:00:00 2001 From: Andreas Fitzek Date: Wed, 27 Nov 2013 10:05:17 +0100 Subject: MOA integration sign/verification (not finished yet ...) Lots of PDF-AS Web implementation --- .../java/at/gv/egiz/moa/ByteArrayDataSource.java | 37 + .../src/main/java/at/gv/egiz/moa/MOAFault.java | 43 + .../SignatureCreationServiceCallbackHandler.java | 82 + .../gv/egiz/moa/SignatureCreationServiceStub.java | 71259 +++++++++++++++++++ ...ignatureVerificationServiceCallbackHandler.java | 82 + .../egiz/moa/SignatureVerificationServiceStub.java | 71259 +++++++++++++++++++ .../src/main/java/at/gv/egiz/moa/package-info.java | 8 + 7 files changed, 142770 insertions(+) create mode 100644 pdf-as-lib/src/main/java/at/gv/egiz/moa/ByteArrayDataSource.java create mode 100644 pdf-as-lib/src/main/java/at/gv/egiz/moa/MOAFault.java create mode 100644 pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceCallbackHandler.java create mode 100644 pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceStub.java create mode 100644 pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceCallbackHandler.java create mode 100644 pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceStub.java create mode 100644 pdf-as-lib/src/main/java/at/gv/egiz/moa/package-info.java (limited to 'pdf-as-lib/src/main/java/at/gv/egiz/moa') diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/moa/ByteArrayDataSource.java b/pdf-as-lib/src/main/java/at/gv/egiz/moa/ByteArrayDataSource.java new file mode 100644 index 00000000..aec5f070 --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/moa/ByteArrayDataSource.java @@ -0,0 +1,37 @@ +package at.gv.egiz.moa; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; + +import javax.activation.DataSource; + +public class ByteArrayDataSource implements DataSource { + + private byte[] data; + private String mimeType; + + public ByteArrayDataSource(byte[] data, String mime) { + this.data = data; + this.mimeType = mime; + } + + public String getContentType() { + return this.mimeType; + } + + public InputStream getInputStream() throws IOException { + return new ByteArrayInputStream(data); + } + + public String getName() { + return null; + } + + public OutputStream getOutputStream() throws IOException { + return null; + } + +} diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/moa/MOAFault.java b/pdf-as-lib/src/main/java/at/gv/egiz/moa/MOAFault.java new file mode 100644 index 00000000..3de2c135 --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/moa/MOAFault.java @@ -0,0 +1,43 @@ + +/** + * MOAFault.java + * + * This file was auto-generated from WSDL + * by the Apache Axis2 version: 1.6.2 Built on : Apr 17, 2012 (05:33:49 IST) + */ + +package at.gv.egiz.moa; + +public class MOAFault extends java.lang.Exception{ + + private static final long serialVersionUID = 1385038355027L; + + private at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse faultMessage; + + + public MOAFault() { + super("MOAFault"); + } + + public MOAFault(java.lang.String s) { + super(s); + } + + public MOAFault(java.lang.String s, java.lang.Throwable ex) { + super(s, ex); + } + + public MOAFault(java.lang.Throwable cause) { + super(cause); + } + + + public void setFaultMessage(at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse msg){ + faultMessage = msg; + } + + public at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse getFaultMessage(){ + return faultMessage; + } +} + \ No newline at end of file diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceCallbackHandler.java b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceCallbackHandler.java new file mode 100644 index 00000000..18fe872e --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceCallbackHandler.java @@ -0,0 +1,82 @@ + +/** + * SignatureCreationServiceCallbackHandler.java + * + * This file was auto-generated from WSDL + * by the Apache Axis2 version: 1.6.2 Built on : Apr 17, 2012 (05:33:49 IST) + */ + + package at.gv.egiz.moa; + + /** + * SignatureCreationServiceCallbackHandler Callback class, Users can extend this class and implement + * their own receiveResult and receiveError methods. + */ + public abstract class SignatureCreationServiceCallbackHandler{ + + + + protected Object clientData; + + /** + * User can pass in any object that needs to be accessed once the NonBlocking + * Web service call is finished and appropriate method of this CallBack is called. + * @param clientData Object mechanism by which the user can pass in user data + * that will be avilable at the time this callback is called. + */ + public SignatureCreationServiceCallbackHandler(Object clientData){ + this.clientData = clientData; + } + + /** + * Please use this constructor if you don't want to set any clientData + */ + public SignatureCreationServiceCallbackHandler(){ + this.clientData = null; + } + + /** + * Get the client data + */ + + public Object getClientData() { + return clientData; + } + + + /** + * auto generated Axis2 call back method for createXMLSignature method + * override this method for handling normal response from createXMLSignature operation + */ + public void receiveResultcreateXMLSignature( + at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse result + ) { + } + + /** + * auto generated Axis2 Error handler + * override this method for handling error response from createXMLSignature operation + */ + public void receiveErrorcreateXMLSignature(java.lang.Exception e) { + } + + /** + * auto generated Axis2 call back method for createCMSSignature method + * override this method for handling normal response from createCMSSignature operation + */ + public void receiveResultcreateCMSSignature( + at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse result + ) { + } + + /** + * auto generated Axis2 Error handler + * override this method for handling error response from createCMSSignature operation + */ + public void receiveErrorcreateCMSSignature(java.lang.Exception e) { + } + + + + } + \ No newline at end of file diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceStub.java b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceStub.java new file mode 100644 index 00000000..f543978f --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureCreationServiceStub.java @@ -0,0 +1,71259 @@ + +/** + * SignatureCreationServiceStub.java + * + * This file was auto-generated from WSDL + * by the Apache Axis2 version: 1.6.2 Built on : Apr 17, 2012 (05:33:49 IST) + */ + package at.gv.egiz.moa; + + + + /* + * SignatureCreationServiceStub java implementation + */ + + + public class SignatureCreationServiceStub extends org.apache.axis2.client.Stub + { + protected org.apache.axis2.description.AxisOperation[] _operations; + + //hashmaps to keep the fault mapping + private java.util.HashMap faultExceptionNameMap = new java.util.HashMap(); + private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap(); + private java.util.HashMap faultMessageMap = new java.util.HashMap(); + + private static int counter = 0; + + private static synchronized java.lang.String getUniqueSuffix(){ + // reset the counter if it is greater than 99999 + if (counter > 99999){ + counter = 0; + } + counter = counter + 1; + return java.lang.Long.toString(java.lang.System.currentTimeMillis()) + "_" + counter; + } + + + private void populateAxisService() throws org.apache.axis2.AxisFault { + + //creating the Service with a unique name + _service = new org.apache.axis2.description.AxisService("SignatureCreationService" + getUniqueSuffix()); + addAnonymousOperations(); + + //creating the operations + org.apache.axis2.description.AxisOperation __operation; + + _operations = new org.apache.axis2.description.AxisOperation[2]; + + __operation = new org.apache.axis2.description.OutInAxisOperation(); + + + __operation.setName(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", "createXMLSignature")); + _service.addOperation(__operation); + + + + + _operations[0]=__operation; + + + __operation = new org.apache.axis2.description.OutInAxisOperation(); + + + __operation.setName(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", "createCMSSignature")); + _service.addOperation(__operation); + + + + + _operations[1]=__operation; + + + } + + //populates the faults + private void populateFaults(){ + + faultExceptionNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "createXMLSignature"),"at.gv.egiz.moa.MOAFault"); + faultExceptionClassNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "createXMLSignature"),"at.gv.egiz.moa.MOAFault"); + faultMessageMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "createXMLSignature"),"at.gv.egiz.moa.SignatureCreationServiceStub$ErrorResponse"); + + faultExceptionNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "createCMSSignature"),"at.gv.egiz.moa.MOAFault"); + faultExceptionClassNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "createCMSSignature"),"at.gv.egiz.moa.MOAFault"); + faultMessageMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "createCMSSignature"),"at.gv.egiz.moa.SignatureCreationServiceStub$ErrorResponse"); + + + + } + + /** + *Constructor that takes in a configContext + */ + + public SignatureCreationServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext, + java.lang.String targetEndpoint) + throws org.apache.axis2.AxisFault { + this(configurationContext,targetEndpoint,false); + } + + + /** + * Constructor that takes in a configContext and useseperate listner + */ + public SignatureCreationServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext, + java.lang.String targetEndpoint, boolean useSeparateListener) + throws org.apache.axis2.AxisFault { + //To populate AxisService + populateAxisService(); + populateFaults(); + + _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service); + + + _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference( + targetEndpoint)); + _serviceClient.getOptions().setUseSeparateListener(useSeparateListener); + + + } + + /** + * Default Constructor + */ + public SignatureCreationServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault { + + this(configurationContext,"" ); + + } + + /** + * Default Constructor + */ + public SignatureCreationServiceStub() throws org.apache.axis2.AxisFault { + + this("" ); + + } + + /** + * Constructor taking the target endpoint + */ + public SignatureCreationServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault { + this(null,targetEndpoint); + } + + + + + /** + * Auto generated method signature + * + * @see at.gv.egiz.moa.SignatureCreationService#createXMLSignature + * @param createXMLSignatureRequest0 + + * @throws at.gv.egiz.moa.MOAFault : + */ + + + + public at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse createXMLSignature( + + at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest createXMLSignatureRequest0) + + + throws java.rmi.RemoteException + + + ,at.gv.egiz.moa.MOAFault{ + org.apache.axis2.context.MessageContext _messageContext = null; + try{ + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName()); + _operationClient.getOptions().setAction("urn:CreateXMLSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + // create a message context + _messageContext = new org.apache.axis2.context.MessageContext(); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env = null; + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + createXMLSignatureRequest0, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createXMLSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createXMLSignature")); + + //adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // set the message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message contxt to the operation client + _operationClient.addMessageContext(_messageContext); + + //execute the operation client + _operationClient.execute(true); + + + org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext( + org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE); + org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope(); + + + java.lang.Object object = fromOM( + _returnEnv.getBody().getFirstElement() , + at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse.class, + getEnvelopeNamespaces(_returnEnv)); + + + return (at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse)object; + + }catch(org.apache.axis2.AxisFault f){ + + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createXMLSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createXMLSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createXMLSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + throw (at.gv.egiz.moa.MOAFault)ex; + } + + + throw new java.rmi.RemoteException(ex.getMessage(), ex); + }catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + }catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } + }else{ + throw f; + } + }else{ + throw f; + } + } finally { + if (_messageContext.getTransportOut() != null) { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } + } + } + + /** + * Auto generated method signature for Asynchronous Invocations + * + * @see at.gv.egiz.moa.SignatureCreationService#startcreateXMLSignature + * @param createXMLSignatureRequest0 + + */ + public void startcreateXMLSignature( + + at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest createXMLSignatureRequest0, + + final at.gv.egiz.moa.SignatureCreationServiceCallbackHandler callback) + + throws java.rmi.RemoteException{ + + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName()); + _operationClient.getOptions().setAction("urn:CreateXMLSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env=null; + final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext(); + + + //Style is Doc. + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + createXMLSignatureRequest0, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createXMLSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createXMLSignature")); + + // adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // create message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message context to the operation client + _operationClient.addMessageContext(_messageContext); + + + + _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() { + public void onMessage(org.apache.axis2.context.MessageContext resultContext) { + try { + org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope(); + + java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(), + at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse.class, + getEnvelopeNamespaces(resultEnv)); + callback.receiveResultcreateXMLSignature( + (at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse)object); + + } catch (org.apache.axis2.AxisFault e) { + callback.receiveErrorcreateXMLSignature(e); + } + } + + public void onError(java.lang.Exception error) { + if (error instanceof org.apache.axis2.AxisFault) { + org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error; + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createXMLSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createXMLSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createXMLSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + callback.receiveErrorcreateXMLSignature((at.gv.egiz.moa.MOAFault)ex); + return; + } + + + callback.receiveErrorcreateXMLSignature(new java.rmi.RemoteException(ex.getMessage(), ex)); + } catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateXMLSignature(f); + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateXMLSignature(f); + } catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateXMLSignature(f); + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateXMLSignature(f); + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateXMLSignature(f); + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateXMLSignature(f); + } catch (org.apache.axis2.AxisFault e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateXMLSignature(f); + } + } else { + callback.receiveErrorcreateXMLSignature(f); + } + } else { + callback.receiveErrorcreateXMLSignature(f); + } + } else { + callback.receiveErrorcreateXMLSignature(error); + } + } + + public void onFault(org.apache.axis2.context.MessageContext faultContext) { + org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext); + onError(fault); + } + + public void onComplete() { + try { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } catch (org.apache.axis2.AxisFault axisFault) { + callback.receiveErrorcreateXMLSignature(axisFault); + } + } + }); + + + org.apache.axis2.util.CallbackReceiver _callbackReceiver = null; + if ( _operations[0].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) { + _callbackReceiver = new org.apache.axis2.util.CallbackReceiver(); + _operations[0].setMessageReceiver( + _callbackReceiver); + } + + //execute the operation client + _operationClient.execute(false); + + } + + /** + * Auto generated method signature + * + * @see at.gv.egiz.moa.SignatureCreationService#createCMSSignature + * @param createCMSSignatureRequest2 + + * @throws at.gv.egiz.moa.MOAFault : + */ + + + + public at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse createCMSSignature( + + at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest createCMSSignatureRequest2) + + + throws java.rmi.RemoteException + + + ,at.gv.egiz.moa.MOAFault{ + org.apache.axis2.context.MessageContext _messageContext = null; + try{ + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName()); + _operationClient.getOptions().setAction("urn:CreateCMSSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + // create a message context + _messageContext = new org.apache.axis2.context.MessageContext(); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env = null; + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + createCMSSignatureRequest2, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createCMSSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createCMSSignature")); + + //adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // set the message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message contxt to the operation client + _operationClient.addMessageContext(_messageContext); + + //execute the operation client + _operationClient.execute(true); + + + org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext( + org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE); + org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope(); + + + java.lang.Object object = fromOM( + _returnEnv.getBody().getFirstElement() , + at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse.class, + getEnvelopeNamespaces(_returnEnv)); + + + return (at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse)object; + + }catch(org.apache.axis2.AxisFault f){ + + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createCMSSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createCMSSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createCMSSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + throw (at.gv.egiz.moa.MOAFault)ex; + } + + + throw new java.rmi.RemoteException(ex.getMessage(), ex); + }catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + }catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } + }else{ + throw f; + } + }else{ + throw f; + } + } finally { + if (_messageContext.getTransportOut() != null) { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } + } + } + + /** + * Auto generated method signature for Asynchronous Invocations + * + * @see at.gv.egiz.moa.SignatureCreationService#startcreateCMSSignature + * @param createCMSSignatureRequest2 + + */ + public void startcreateCMSSignature( + + at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest createCMSSignatureRequest2, + + final at.gv.egiz.moa.SignatureCreationServiceCallbackHandler callback) + + throws java.rmi.RemoteException{ + + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName()); + _operationClient.getOptions().setAction("urn:CreateCMSSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env=null; + final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext(); + + + //Style is Doc. + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + createCMSSignatureRequest2, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createCMSSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "createCMSSignature")); + + // adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // create message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message context to the operation client + _operationClient.addMessageContext(_messageContext); + + + + _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() { + public void onMessage(org.apache.axis2.context.MessageContext resultContext) { + try { + org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope(); + + java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(), + at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse.class, + getEnvelopeNamespaces(resultEnv)); + callback.receiveResultcreateCMSSignature( + (at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse)object); + + } catch (org.apache.axis2.AxisFault e) { + callback.receiveErrorcreateCMSSignature(e); + } + } + + public void onError(java.lang.Exception error) { + if (error instanceof org.apache.axis2.AxisFault) { + org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error; + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createCMSSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createCMSSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"createCMSSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + callback.receiveErrorcreateCMSSignature((at.gv.egiz.moa.MOAFault)ex); + return; + } + + + callback.receiveErrorcreateCMSSignature(new java.rmi.RemoteException(ex.getMessage(), ex)); + } catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateCMSSignature(f); + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateCMSSignature(f); + } catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateCMSSignature(f); + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateCMSSignature(f); + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateCMSSignature(f); + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateCMSSignature(f); + } catch (org.apache.axis2.AxisFault e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorcreateCMSSignature(f); + } + } else { + callback.receiveErrorcreateCMSSignature(f); + } + } else { + callback.receiveErrorcreateCMSSignature(f); + } + } else { + callback.receiveErrorcreateCMSSignature(error); + } + } + + public void onFault(org.apache.axis2.context.MessageContext faultContext) { + org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext); + onError(fault); + } + + public void onComplete() { + try { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } catch (org.apache.axis2.AxisFault axisFault) { + callback.receiveErrorcreateCMSSignature(axisFault); + } + } + }); + + + org.apache.axis2.util.CallbackReceiver _callbackReceiver = null; + if ( _operations[1].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) { + _callbackReceiver = new org.apache.axis2.util.CallbackReceiver(); + _operations[1].setMessageReceiver( + _callbackReceiver); + } + + //execute the operation client + _operationClient.execute(false); + + } + + + + /** + * A utility method that copies the namepaces from the SOAPEnvelope + */ + private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){ + java.util.Map returnMap = new java.util.HashMap(); + java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces(); + while (namespaceIterator.hasNext()) { + org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next(); + returnMap.put(ns.getPrefix(),ns.getNamespaceURI()); + } + return returnMap; + } + + + + private javax.xml.namespace.QName[] opNameArray = null; + private boolean optimizeContent(javax.xml.namespace.QName opName) { + + + if (opNameArray == null) { + return false; + } + for (int i = 0; i < opNameArray.length; i++) { + if (opName.equals(opNameArray[i])) { + return true; + } + } + return false; + } + // + public static class PGPData + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "PGPData", + "ns1"); + + + + /** + * field for PGPData + */ + + + protected PGPDataType localPGPData ; + + + /** + * Auto generated getter method + * @return PGPDataType + */ + public PGPDataType getPGPData(){ + return localPGPData; + } + + + + /** + * Auto generated setter method + * @param param PGPData + */ + public void setPGPData(PGPDataType param){ + + this.localPGPData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localPGPData==null){ + throw new org.apache.axis2.databinding.ADBException("PGPData cannot be null!"); + } + localPGPData.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localPGPData.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPData parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPData object = + new PGPData(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPData").equals(reader.getName())){ + + object.setPGPData(PGPDataType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentOptionalRefType extends ContentBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentOptionalRefType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Reference + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localReference ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getReference(){ + return localReference; + } + + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(org.apache.axis2.databinding.types.URI param){ + + this.localReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentOptionalRefType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentOptionalRefType", + xmlWriter); + } + + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ContentOptionalRefType")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentOptionalRefType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentOptionalRefType object = + new ContentOptionalRefType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentOptionalRefType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentOptionalRefType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyXMLSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for SignerInfo + */ + + + protected KeyInfoType localSignerInfo ; + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getSignerInfo(){ + return localSignerInfo; + } + + + + /** + * Auto generated setter method + * @param param SignerInfo + */ + public void setSignerInfo(KeyInfoType param){ + + this.localSignerInfo=param; + + + } + + + /** + * field for HashInputData + * This was an Array! + */ + + + protected InputDataType[] localHashInputData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localHashInputDataTracker = false ; + + public boolean isHashInputDataSpecified(){ + return localHashInputDataTracker; + } + + + + /** + * Auto generated getter method + * @return InputDataType[] + */ + public InputDataType[] getHashInputData(){ + return localHashInputData; + } + + + + + + + /** + * validate the array for HashInputData + */ + protected void validateHashInputData(InputDataType[] param){ + + } + + + /** + * Auto generated setter method + * @param param HashInputData + */ + public void setHashInputData(InputDataType[] param){ + + validateHashInputData(param); + + localHashInputDataTracker = param != null; + + this.localHashInputData=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param InputDataType + */ + public void addHashInputData(InputDataType param){ + if (localHashInputData == null){ + localHashInputData = new InputDataType[]{}; + } + + + //update the setting tracker + localHashInputDataTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localHashInputData); + list.add(param); + this.localHashInputData = + (InputDataType[])list.toArray( + new InputDataType[list.size()]); + + } + + + /** + * field for ReferenceInputData + * This was an Array! + */ + + + protected InputDataType[] localReferenceInputData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localReferenceInputDataTracker = false ; + + public boolean isReferenceInputDataSpecified(){ + return localReferenceInputDataTracker; + } + + + + /** + * Auto generated getter method + * @return InputDataType[] + */ + public InputDataType[] getReferenceInputData(){ + return localReferenceInputData; + } + + + + + + + /** + * validate the array for ReferenceInputData + */ + protected void validateReferenceInputData(InputDataType[] param){ + + } + + + /** + * Auto generated setter method + * @param param ReferenceInputData + */ + public void setReferenceInputData(InputDataType[] param){ + + validateReferenceInputData(param); + + localReferenceInputDataTracker = param != null; + + this.localReferenceInputData=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param InputDataType + */ + public void addReferenceInputData(InputDataType param){ + if (localReferenceInputData == null){ + localReferenceInputData = new InputDataType[]{}; + } + + + //update the setting tracker + localReferenceInputDataTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReferenceInputData); + list.add(param); + this.localReferenceInputData = + (InputDataType[])list.toArray( + new InputDataType[list.size()]); + + } + + + /** + * field for SignatureCheck + */ + + + protected ReferencesCheckResultType localSignatureCheck ; + + + /** + * Auto generated getter method + * @return ReferencesCheckResultType + */ + public ReferencesCheckResultType getSignatureCheck(){ + return localSignatureCheck; + } + + + + /** + * Auto generated setter method + * @param param SignatureCheck + */ + public void setSignatureCheck(ReferencesCheckResultType param){ + + this.localSignatureCheck=param; + + + } + + + /** + * field for SignatureManifestCheck + */ + + + protected ReferencesCheckResultType localSignatureManifestCheck ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSignatureManifestCheckTracker = false ; + + public boolean isSignatureManifestCheckSpecified(){ + return localSignatureManifestCheckTracker; + } + + + + /** + * Auto generated getter method + * @return ReferencesCheckResultType + */ + public ReferencesCheckResultType getSignatureManifestCheck(){ + return localSignatureManifestCheck; + } + + + + /** + * Auto generated setter method + * @param param SignatureManifestCheck + */ + public void setSignatureManifestCheck(ReferencesCheckResultType param){ + localSignatureManifestCheckTracker = param != null; + + this.localSignatureManifestCheck=param; + + + } + + + /** + * field for XMLDSIGManifestCheck + * This was an Array! + */ + + + protected ManifestRefsCheckResultType[] localXMLDSIGManifestCheck ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLDSIGManifestCheckTracker = false ; + + public boolean isXMLDSIGManifestCheckSpecified(){ + return localXMLDSIGManifestCheckTracker; + } + + + + /** + * Auto generated getter method + * @return ManifestRefsCheckResultType[] + */ + public ManifestRefsCheckResultType[] getXMLDSIGManifestCheck(){ + return localXMLDSIGManifestCheck; + } + + + + + + + /** + * validate the array for XMLDSIGManifestCheck + */ + protected void validateXMLDSIGManifestCheck(ManifestRefsCheckResultType[] param){ + + } + + + /** + * Auto generated setter method + * @param param XMLDSIGManifestCheck + */ + public void setXMLDSIGManifestCheck(ManifestRefsCheckResultType[] param){ + + validateXMLDSIGManifestCheck(param); + + localXMLDSIGManifestCheckTracker = param != null; + + this.localXMLDSIGManifestCheck=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ManifestRefsCheckResultType + */ + public void addXMLDSIGManifestCheck(ManifestRefsCheckResultType param){ + if (localXMLDSIGManifestCheck == null){ + localXMLDSIGManifestCheck = new ManifestRefsCheckResultType[]{}; + } + + + //update the setting tracker + localXMLDSIGManifestCheckTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localXMLDSIGManifestCheck); + list.add(param); + this.localXMLDSIGManifestCheck = + (ManifestRefsCheckResultType[])list.toArray( + new ManifestRefsCheckResultType[list.size()]); + + } + + + /** + * field for CertificateCheck + */ + + + protected CheckResultType localCertificateCheck ; + + + /** + * Auto generated getter method + * @return CheckResultType + */ + public CheckResultType getCertificateCheck(){ + return localCertificateCheck; + } + + + + /** + * Auto generated setter method + * @param param CertificateCheck + */ + public void setCertificateCheck(CheckResultType param){ + + this.localCertificateCheck=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyXMLSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyXMLSignatureResponseType", + xmlWriter); + } + + + } + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + localSignerInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo"), + xmlWriter); + if (localHashInputDataTracker){ + if (localHashInputData!=null){ + for (int i = 0;i < localHashInputData.length;i++){ + if (localHashInputData[i] != null){ + localHashInputData[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","HashInputData"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("HashInputData cannot be null!!"); + + } + } if (localReferenceInputDataTracker){ + if (localReferenceInputData!=null){ + for (int i = 0;i < localReferenceInputData.length;i++){ + if (localReferenceInputData[i] != null){ + localReferenceInputData[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInputData"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInputData cannot be null!!"); + + } + } + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + localSignatureCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck"), + xmlWriter); + if (localSignatureManifestCheckTracker){ + if (localSignatureManifestCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheck cannot be null!!"); + } + localSignatureManifestCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheck"), + xmlWriter); + } if (localXMLDSIGManifestCheckTracker){ + if (localXMLDSIGManifestCheck!=null){ + for (int i = 0;i < localXMLDSIGManifestCheck.length;i++){ + if (localXMLDSIGManifestCheck[i] != null){ + localXMLDSIGManifestCheck[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLDSIGManifestCheck"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("XMLDSIGManifestCheck cannot be null!!"); + + } + } + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + localCertificateCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignerInfo")); + + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + elementList.add(localSignerInfo); + if (localHashInputDataTracker){ + if (localHashInputData!=null) { + for (int i = 0;i < localHashInputData.length;i++){ + + if (localHashInputData[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "HashInputData")); + elementList.add(localHashInputData[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("HashInputData cannot be null!!"); + + } + + } if (localReferenceInputDataTracker){ + if (localReferenceInputData!=null) { + for (int i = 0;i < localReferenceInputData.length;i++){ + + if (localReferenceInputData[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReferenceInputData")); + elementList.add(localReferenceInputData[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInputData cannot be null!!"); + + } + + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureCheck")); + + + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + elementList.add(localSignatureCheck); + if (localSignatureManifestCheckTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureManifestCheck")); + + + if (localSignatureManifestCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheck cannot be null!!"); + } + elementList.add(localSignatureManifestCheck); + } if (localXMLDSIGManifestCheckTracker){ + if (localXMLDSIGManifestCheck!=null) { + for (int i = 0;i < localXMLDSIGManifestCheck.length;i++){ + + if (localXMLDSIGManifestCheck[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLDSIGManifestCheck")); + elementList.add(localXMLDSIGManifestCheck[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("XMLDSIGManifestCheck cannot be null!!"); + + } + + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CertificateCheck")); + + + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + elementList.add(localCertificateCheck); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureResponseType object = + new VerifyXMLSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyXMLSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyXMLSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + java.util.ArrayList list6 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo").equals(reader.getName())){ + + object.setSignerInfo(KeyInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","HashInputData").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(InputDataType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","HashInputData").equals(reader.getName())){ + list2.add(InputDataType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setHashInputData((InputDataType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + InputDataType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInputData").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list3.add(InputDataType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone3 = false; + while(!loopDone3){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone3 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInputData").equals(reader.getName())){ + list3.add(InputDataType.Factory.parse(reader)); + + }else{ + loopDone3 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReferenceInputData((InputDataType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + InputDataType.class, + list3)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck").equals(reader.getName())){ + + object.setSignatureCheck(ReferencesCheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheck").equals(reader.getName())){ + + object.setSignatureManifestCheck(ReferencesCheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLDSIGManifestCheck").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list6.add(ManifestRefsCheckResultType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone6 = false; + while(!loopDone6){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone6 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLDSIGManifestCheck").equals(reader.getName())){ + list6.add(ManifestRefsCheckResultType.Factory.parse(reader)); + + }else{ + loopDone6 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setXMLDSIGManifestCheck((ManifestRefsCheckResultType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ManifestRefsCheckResultType.class, + list6)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck").equals(reader.getName())){ + + object.setCertificateCheck(CheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsInfoProfile_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyTransformsInfoProfile_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for TransformParameter + * This was an Array! + */ + + + protected TransformParameterType[] localTransformParameter ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformParameterTracker = false ; + + public boolean isTransformParameterSpecified(){ + return localTransformParameterTracker; + } + + + + /** + * Auto generated getter method + * @return TransformParameterType[] + */ + public TransformParameterType[] getTransformParameter(){ + return localTransformParameter; + } + + + + + + + /** + * validate the array for TransformParameter + */ + protected void validateTransformParameter(TransformParameterType[] param){ + + } + + + /** + * Auto generated setter method + * @param param TransformParameter + */ + public void setTransformParameter(TransformParameterType[] param){ + + validateTransformParameter(param); + + localTransformParameterTracker = param != null; + + this.localTransformParameter=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param TransformParameterType + */ + public void addTransformParameter(TransformParameterType param){ + if (localTransformParameter == null){ + localTransformParameter = new TransformParameterType[]{}; + } + + + //update the setting tracker + localTransformParameterTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localTransformParameter); + list.add(param); + this.localTransformParameter = + (TransformParameterType[])list.toArray( + new TransformParameterType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyTransformsInfoProfile_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyTransformsInfoProfile_type0", + xmlWriter); + } + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } if (localTransformParameterTracker){ + if (localTransformParameter!=null){ + for (int i = 0;i < localTransformParameter.length;i++){ + if (localTransformParameter[i] != null){ + localTransformParameter[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TransformParameter"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("TransformParameter cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } if (localTransformParameterTracker){ + if (localTransformParameter!=null) { + for (int i = 0;i < localTransformParameter.length;i++){ + + if (localTransformParameter[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TransformParameter")); + elementList.add(localTransformParameter[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("TransformParameter cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsInfoProfile_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsInfoProfile_type0 object = + new VerifyTransformsInfoProfile_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyTransformsInfoProfile_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyTransformsInfoProfile_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TransformParameter").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(TransformParameterType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TransformParameter").equals(reader.getName())){ + list2.add(TransformParameterType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setTransformParameter((TransformParameterType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + TransformParameterType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SPKIData + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SPKIData", + "ns1"); + + + + /** + * field for SPKIData + */ + + + protected SPKIDataType localSPKIData ; + + + /** + * Auto generated getter method + * @return SPKIDataType + */ + public SPKIDataType getSPKIData(){ + return localSPKIData; + } + + + + /** + * Auto generated setter method + * @param param SPKIData + */ + public void setSPKIData(SPKIDataType param){ + + this.localSPKIData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSPKIData==null){ + throw new org.apache.axis2.databinding.ADBException("SPKIData cannot be null!"); + } + localSPKIData.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSPKIData.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SPKIData parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SPKIData object = + new SPKIData(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKIData").equals(reader.getName())){ + + object.setSPKIData(SPKIDataType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSDataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSDataObjectInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObject + */ + + + protected DataObject_type1 localDataObject ; + + + /** + * Auto generated getter method + * @return DataObject_type1 + */ + public DataObject_type1 getDataObject(){ + return localDataObject; + } + + + + /** + * Auto generated setter method + * @param param DataObject + */ + public void setDataObject(DataObject_type1 param){ + + this.localDataObject=param; + + + } + + + /** + * field for Structure + * This was an Attribute! + */ + + + protected Structure_type1 localStructure ; + + + /** + * Auto generated getter method + * @return Structure_type1 + */ + public Structure_type1 getStructure(){ + return localStructure; + } + + + + /** + * Auto generated setter method + * @param param Structure + */ + public void setStructure(Structure_type1 param){ + + this.localStructure=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSDataObjectInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSDataObjectInfoType", + xmlWriter); + } + + + } + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSDataObjectInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSDataObjectInfoType object = + new CMSDataObjectInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSDataObjectInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSDataObjectInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type1.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type1.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PartOf_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "PartOf_type0", + "ns2"); + + + + /** + * field for PartOf_type0 + */ + + + protected org.apache.axis2.databinding.types.Token localPartOf_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected PartOf_type0(org.apache.axis2.databinding.types.Token value, boolean isRegisterValue) { + localPartOf_type0 = value; + if (isRegisterValue){ + + _table_.put(localPartOf_type0, this); + + } + + } + + public static final org.apache.axis2.databinding.types.Token _SignedInfo = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("SignedInfo"); + + public static final org.apache.axis2.databinding.types.Token _XMLDSIGManifest = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("XMLDSIGManifest"); + + public static final PartOf_type0 SignedInfo = + new PartOf_type0(_SignedInfo,true); + + public static final PartOf_type0 XMLDSIGManifest = + new PartOf_type0(_XMLDSIGManifest,true); + + + public org.apache.axis2.databinding.types.Token getValue() { return localPartOf_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localPartOf_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PartOf_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PartOf_type0", + xmlWriter); + } + } + + if (localPartOf_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("PartOf_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPartOf_type0)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPartOf_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static PartOf_type0 fromValue(org.apache.axis2.databinding.types.Token value) + throws java.lang.IllegalArgumentException { + PartOf_type0 enumeration = (PartOf_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static PartOf_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static PartOf_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return PartOf_type0.Factory.fromString(content,namespaceUri); + } else { + return PartOf_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PartOf_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PartOf_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"PartOf_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = PartOf_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = PartOf_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValueTypeSequence_type1 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DSAKeyValueTypeSequence_type1 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Seed + */ + + + protected CryptoBinary localSeed ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getSeed(){ + return localSeed; + } + + + + /** + * Auto generated setter method + * @param param Seed + */ + public void setSeed(CryptoBinary param){ + + this.localSeed=param; + + + } + + + /** + * field for PgenCounter + */ + + + protected CryptoBinary localPgenCounter ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getPgenCounter(){ + return localPgenCounter; + } + + + + /** + * Auto generated setter method + * @param param PgenCounter + */ + public void setPgenCounter(CryptoBinary param){ + + this.localPgenCounter=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DSAKeyValueTypeSequence_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DSAKeyValueTypeSequence_type1", + xmlWriter); + } + + + } + + if (localSeed==null){ + throw new org.apache.axis2.databinding.ADBException("Seed cannot be null!!"); + } + localSeed.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Seed"), + xmlWriter); + + if (localPgenCounter==null){ + throw new org.apache.axis2.databinding.ADBException("PgenCounter cannot be null!!"); + } + localPgenCounter.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PgenCounter"), + xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Seed")); + + + if (localSeed==null){ + throw new org.apache.axis2.databinding.ADBException("Seed cannot be null!!"); + } + elementList.add(localSeed); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PgenCounter")); + + + if (localPgenCounter==null){ + throw new org.apache.axis2.databinding.ADBException("PgenCounter cannot be null!!"); + } + elementList.add(localPgenCounter); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValueTypeSequence_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValueTypeSequence_type1 object = + new DSAKeyValueTypeSequence_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Seed").equals(reader.getName())){ + + object.setSeed(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PgenCounter").equals(reader.getName())){ + + object.setPgenCounter(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValueTypeSequence_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DSAKeyValueTypeSequence_type0 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for P + */ + + + protected CryptoBinary localP ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getP(){ + return localP; + } + + + + /** + * Auto generated setter method + * @param param P + */ + public void setP(CryptoBinary param){ + + this.localP=param; + + + } + + + /** + * field for Q + */ + + + protected CryptoBinary localQ ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getQ(){ + return localQ; + } + + + + /** + * Auto generated setter method + * @param param Q + */ + public void setQ(CryptoBinary param){ + + this.localQ=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DSAKeyValueTypeSequence_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DSAKeyValueTypeSequence_type0", + xmlWriter); + } + + + } + + if (localP==null){ + throw new org.apache.axis2.databinding.ADBException("P cannot be null!!"); + } + localP.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","P"), + xmlWriter); + + if (localQ==null){ + throw new org.apache.axis2.databinding.ADBException("Q cannot be null!!"); + } + localQ.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Q"), + xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "P")); + + + if (localP==null){ + throw new org.apache.axis2.databinding.ADBException("P cannot be null!!"); + } + elementList.add(localP); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Q")); + + + if (localQ==null){ + throw new org.apache.axis2.databinding.ADBException("Q cannot be null!!"); + } + elementList.add(localQ); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValueTypeSequence_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValueTypeSequence_type0 object = + new DSAKeyValueTypeSequence_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","P").equals(reader.getName())){ + + object.setP(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Q").equals(reader.getName())){ + + object.setQ(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509DataTypeChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509DataTypeChoice_type0 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localX509IssuerSerialTracker = false; + + localX509SKITracker = false; + + localX509SubjectNameTracker = false; + + localX509CertificateTracker = false; + + localX509CRLTracker = false; + + localExtraElementTracker = false; + + } + + + /** + * field for X509IssuerSerial + */ + + + protected X509IssuerSerialType localX509IssuerSerial ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509IssuerSerialTracker = false ; + + public boolean isX509IssuerSerialSpecified(){ + return localX509IssuerSerialTracker; + } + + + + /** + * Auto generated getter method + * @return X509IssuerSerialType + */ + public X509IssuerSerialType getX509IssuerSerial(){ + return localX509IssuerSerial; + } + + + + /** + * Auto generated setter method + * @param param X509IssuerSerial + */ + public void setX509IssuerSerial(X509IssuerSerialType param){ + + clearAllSettingTrackers(); + localX509IssuerSerialTracker = param != null; + + this.localX509IssuerSerial=param; + + + } + + + /** + * field for X509SKI + */ + + + protected javax.activation.DataHandler localX509SKI ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509SKITracker = false ; + + public boolean isX509SKISpecified(){ + return localX509SKITracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getX509SKI(){ + return localX509SKI; + } + + + + /** + * Auto generated setter method + * @param param X509SKI + */ + public void setX509SKI(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localX509SKITracker = param != null; + + this.localX509SKI=param; + + + } + + + /** + * field for X509SubjectName + */ + + + protected java.lang.String localX509SubjectName ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509SubjectNameTracker = false ; + + public boolean isX509SubjectNameSpecified(){ + return localX509SubjectNameTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getX509SubjectName(){ + return localX509SubjectName; + } + + + + /** + * Auto generated setter method + * @param param X509SubjectName + */ + public void setX509SubjectName(java.lang.String param){ + + clearAllSettingTrackers(); + localX509SubjectNameTracker = param != null; + + this.localX509SubjectName=param; + + + } + + + /** + * field for X509Certificate + */ + + + protected javax.activation.DataHandler localX509Certificate ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509CertificateTracker = false ; + + public boolean isX509CertificateSpecified(){ + return localX509CertificateTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getX509Certificate(){ + return localX509Certificate; + } + + + + /** + * Auto generated setter method + * @param param X509Certificate + */ + public void setX509Certificate(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localX509CertificateTracker = param != null; + + this.localX509Certificate=param; + + + } + + + /** + * field for X509CRL + */ + + + protected javax.activation.DataHandler localX509CRL ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509CRLTracker = false ; + + public boolean isX509CRLSpecified(){ + return localX509CRLTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getX509CRL(){ + return localX509CRL; + } + + + + /** + * Auto generated setter method + * @param param X509CRL + */ + public void setX509CRL(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localX509CRLTracker = param != null; + + this.localX509CRL=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509DataTypeChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509DataTypeChoice_type0", + xmlWriter); + } + + + } + if (localX509IssuerSerialTracker){ + if (localX509IssuerSerial==null){ + throw new org.apache.axis2.databinding.ADBException("X509IssuerSerial cannot be null!!"); + } + localX509IssuerSerial.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509IssuerSerial"), + xmlWriter); + } if (localX509SKITracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509SKI", xmlWriter); + + + if (localX509SKI!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localX509SKI, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for X509SKI", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localX509SubjectNameTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509SubjectName", xmlWriter); + + + if (localX509SubjectName==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("X509SubjectName cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localX509SubjectName); + + } + + xmlWriter.writeEndElement(); + } if (localX509CertificateTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509Certificate", xmlWriter); + + + if (localX509Certificate!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localX509Certificate, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for X509Certificate", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localX509CRLTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509CRL", xmlWriter); + + + if (localX509CRL!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localX509CRL, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for X509CRL", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localX509IssuerSerialTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509IssuerSerial")); + + + if (localX509IssuerSerial==null){ + throw new org.apache.axis2.databinding.ADBException("X509IssuerSerial cannot be null!!"); + } + elementList.add(localX509IssuerSerial); + } if (localX509SKITracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509SKI")); + + elementList.add(localX509SKI); + } if (localX509SubjectNameTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509SubjectName")); + + if (localX509SubjectName != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509SubjectName)); + } else { + throw new org.apache.axis2.databinding.ADBException("X509SubjectName cannot be null!!"); + } + } if (localX509CertificateTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509Certificate")); + + elementList.add(localX509Certificate); + } if (localX509CRLTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509CRL")); + + elementList.add(localX509CRL); + } if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509DataTypeChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509DataTypeChoice_type0 object = + new X509DataTypeChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509IssuerSerial").equals(reader.getName())){ + + object.setX509IssuerSerial(X509IssuerSerialType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509SKI").equals(reader.getName())){ + + object.setX509SKI(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509SubjectName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"X509SubjectName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setX509SubjectName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Certificate").equals(reader.getName())){ + + object.setX509Certificate(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509CRL").equals(reader.getName())){ + + object.setX509CRL(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname6 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder6 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname6); + object.setExtraElement(builder6.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureRequest extends VerifyCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyCMSSignatureRequest", + "ns2"); + + + + /** + * field for Signatories + * This was an Attribute! + */ + + + protected SignatoriesType localSignatories ; + + + /** + * Auto generated getter method + * @return SignatoriesType + */ + public SignatoriesType getSignatories(){ + return localSignatories; + } + + + + /** + * Auto generated setter method + * @param param Signatories + */ + public void setSignatories(SignatoriesType param){ + + this.localSignatories=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureRequest", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureRequest", + xmlWriter); + } + + + } + + + if (localSignatories != null){ + writeAttribute("", + "Signatories", + localSignatories.toString(), xmlWriter); + } + if (localDateTimeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "DateTime", xmlWriter); + + + if (localDateTime==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + + } + + xmlWriter.writeEndElement(); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "CMSSignature", xmlWriter); + + + if (localCMSSignature!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localCMSSignature, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for CMSSignature", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localDataObjectTracker){ + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "TrustProfileID", xmlWriter); + + + if (localTrustProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyCMSSignatureRequest")); + if (localDateTimeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DateTime")); + + if (localDateTime != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + } else { + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CMSSignature")); + + elementList.add(localCMSSignature); + if (localDataObjectTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TrustProfileID")); + + if (localTrustProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Signatories")); + + attribList.add(localSignatories.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureRequest object = + new VerifyCMSSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyCMSSignatureRequest".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyCMSSignatureRequest)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Signatories" + java.lang.String tempAttribSignatories = + + reader.getAttributeValue(null,"Signatories"); + + if (tempAttribSignatories!=null){ + java.lang.String content = tempAttribSignatories; + + object.setSignatories( + SignatoriesType.Factory.fromString(reader,tempAttribSignatories)); + + } else { + + } + handledAttributes.add("Signatories"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DateTime").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DateTime" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDateTime( + org.apache.axis2.databinding.utils.ConverterUtil.convertToDateTime(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CMSSignature").equals(reader.getName())){ + + object.setCMSSignature(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(CMSDataObjectOptionalMetaType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TrustProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"TrustProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setTrustProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PublicAuthority + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "PublicAuthority", + "ns2"); + + + + /** + * field for PublicAuthority + */ + + + protected PublicAuthorityType localPublicAuthority ; + + + /** + * Auto generated getter method + * @return PublicAuthorityType + */ + public PublicAuthorityType getPublicAuthority(){ + return localPublicAuthority; + } + + + + /** + * Auto generated setter method + * @param param PublicAuthority + */ + public void setPublicAuthority(PublicAuthorityType param){ + + this.localPublicAuthority=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localPublicAuthority==null){ + throw new org.apache.axis2.databinding.ADBException("PublicAuthority cannot be null!"); + } + localPublicAuthority.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localPublicAuthority.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PublicAuthority parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PublicAuthority object = + new PublicAuthority(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","PublicAuthority").equals(reader.getName())){ + + object.setPublicAuthority(PublicAuthorityType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ManifestRefsCheckResultInfoType extends AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ManifestRefsCheckResultInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for FailedReference + * This was an Array! + */ + + + protected org.apache.axis2.databinding.types.PositiveInteger[] localFailedReference ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localFailedReferenceTracker = false ; + + public boolean isFailedReferenceSpecified(){ + return localFailedReferenceTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.PositiveInteger[] + */ + public org.apache.axis2.databinding.types.PositiveInteger[] getFailedReference(){ + return localFailedReference; + } + + + + + + + /** + * validate the array for FailedReference + */ + protected void validateFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + } + + + /** + * Auto generated setter method + * @param param FailedReference + */ + public void setFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + validateFailedReference(param); + + localFailedReferenceTracker = param != null; + + this.localFailedReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axis2.databinding.types.PositiveInteger + */ + public void addFailedReference(org.apache.axis2.databinding.types.PositiveInteger param){ + if (localFailedReference == null){ + localFailedReference = new org.apache.axis2.databinding.types.PositiveInteger[]{}; + } + + + //update the setting tracker + localFailedReferenceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localFailedReference); + list.add(param); + this.localFailedReference = + (org.apache.axis2.databinding.types.PositiveInteger[])list.toArray( + new org.apache.axis2.databinding.types.PositiveInteger[list.size()]); + + } + + + /** + * field for ReferringSigReference + */ + + + protected org.apache.axis2.databinding.types.PositiveInteger localReferringSigReference ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.PositiveInteger + */ + public org.apache.axis2.databinding.types.PositiveInteger getReferringSigReference(){ + return localReferringSigReference; + } + + + + /** + * Auto generated setter method + * @param param ReferringSigReference + */ + public void setReferringSigReference(org.apache.axis2.databinding.types.PositiveInteger param){ + + this.localReferringSigReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ManifestRefsCheckResultInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ManifestRefsCheckResultInfoType", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null) { + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + + writeStartElement(null, namespace, "FailedReference", xmlWriter); + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + + xmlWriter.writeEndElement(); + + } else { + + // we have to do nothing since minOccurs is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "ReferringSigReference", xmlWriter); + + + if (localReferringSigReference==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("ReferringSigReference cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null){ + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "FailedReference")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + } else { + + // have to do nothing + + } + + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReferringSigReference")); + + if (localReferringSigReference != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference)); + } else { + throw new org.apache.axis2.databinding.ADBException("ReferringSigReference cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ManifestRefsCheckResultInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ManifestRefsCheckResultInfoType object = + new ManifestRefsCheckResultInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ManifestRefsCheckResultInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ManifestRefsCheckResultInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(reader.getElementText()); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // Ensure we are at the EndElement + while (!reader.isEndElement()){ + reader.next(); + } + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + list2.add(reader.getElementText()); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setFailedReference((org.apache.axis2.databinding.types.PositiveInteger[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axis2.databinding.types.PositiveInteger.class,list2)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferringSigReference").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ReferringSigReference" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setReferringSigReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToPositiveInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CanonicalizationMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "CanonicalizationMethod", + "ns1"); + + + + /** + * field for CanonicalizationMethod + */ + + + protected CanonicalizationMethodType localCanonicalizationMethod ; + + + /** + * Auto generated getter method + * @return CanonicalizationMethodType + */ + public CanonicalizationMethodType getCanonicalizationMethod(){ + return localCanonicalizationMethod; + } + + + + /** + * Auto generated setter method + * @param param CanonicalizationMethod + */ + public void setCanonicalizationMethod(CanonicalizationMethodType param){ + + this.localCanonicalizationMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCanonicalizationMethod==null){ + throw new org.apache.axis2.databinding.ADBException("CanonicalizationMethod cannot be null!"); + } + localCanonicalizationMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCanonicalizationMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CanonicalizationMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CanonicalizationMethod object = + new CanonicalizationMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","CanonicalizationMethod").equals(reader.getName())){ + + object.setCanonicalizationMethod(CanonicalizationMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = AnyChildrenType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":AnyChildrenType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "AnyChildrenType", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static AnyChildrenType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + AnyChildrenType object = + new AnyChildrenType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"AnyChildrenType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (AnyChildrenType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyInfoTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = KeyInfoTypeChoice + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localKeyNameTracker = false; + + localKeyValueTracker = false; + + localRetrievalMethodTracker = false; + + localX509DataTracker = false; + + localPGPDataTracker = false; + + localSPKIDataTracker = false; + + localMgmtDataTracker = false; + + localExtraElementTracker = false; + + } + + + /** + * field for KeyName + */ + + + protected java.lang.String localKeyName ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localKeyNameTracker = false ; + + public boolean isKeyNameSpecified(){ + return localKeyNameTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getKeyName(){ + return localKeyName; + } + + + + /** + * Auto generated setter method + * @param param KeyName + */ + public void setKeyName(java.lang.String param){ + + clearAllSettingTrackers(); + localKeyNameTracker = param != null; + + this.localKeyName=param; + + + } + + + /** + * field for KeyValue + */ + + + protected KeyValueType localKeyValue ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localKeyValueTracker = false ; + + public boolean isKeyValueSpecified(){ + return localKeyValueTracker; + } + + + + /** + * Auto generated getter method + * @return KeyValueType + */ + public KeyValueType getKeyValue(){ + return localKeyValue; + } + + + + /** + * Auto generated setter method + * @param param KeyValue + */ + public void setKeyValue(KeyValueType param){ + + clearAllSettingTrackers(); + localKeyValueTracker = param != null; + + this.localKeyValue=param; + + + } + + + /** + * field for RetrievalMethod + */ + + + protected RetrievalMethodType localRetrievalMethod ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localRetrievalMethodTracker = false ; + + public boolean isRetrievalMethodSpecified(){ + return localRetrievalMethodTracker; + } + + + + /** + * Auto generated getter method + * @return RetrievalMethodType + */ + public RetrievalMethodType getRetrievalMethod(){ + return localRetrievalMethod; + } + + + + /** + * Auto generated setter method + * @param param RetrievalMethod + */ + public void setRetrievalMethod(RetrievalMethodType param){ + + clearAllSettingTrackers(); + localRetrievalMethodTracker = param != null; + + this.localRetrievalMethod=param; + + + } + + + /** + * field for X509Data + */ + + + protected X509DataType localX509Data ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509DataTracker = false ; + + public boolean isX509DataSpecified(){ + return localX509DataTracker; + } + + + + /** + * Auto generated getter method + * @return X509DataType + */ + public X509DataType getX509Data(){ + return localX509Data; + } + + + + /** + * Auto generated setter method + * @param param X509Data + */ + public void setX509Data(X509DataType param){ + + clearAllSettingTrackers(); + localX509DataTracker = param != null; + + this.localX509Data=param; + + + } + + + /** + * field for PGPData + */ + + + protected PGPDataType localPGPData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPDataTracker = false ; + + public boolean isPGPDataSpecified(){ + return localPGPDataTracker; + } + + + + /** + * Auto generated getter method + * @return PGPDataType + */ + public PGPDataType getPGPData(){ + return localPGPData; + } + + + + /** + * Auto generated setter method + * @param param PGPData + */ + public void setPGPData(PGPDataType param){ + + clearAllSettingTrackers(); + localPGPDataTracker = param != null; + + this.localPGPData=param; + + + } + + + /** + * field for SPKIData + */ + + + protected SPKIDataType localSPKIData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSPKIDataTracker = false ; + + public boolean isSPKIDataSpecified(){ + return localSPKIDataTracker; + } + + + + /** + * Auto generated getter method + * @return SPKIDataType + */ + public SPKIDataType getSPKIData(){ + return localSPKIData; + } + + + + /** + * Auto generated setter method + * @param param SPKIData + */ + public void setSPKIData(SPKIDataType param){ + + clearAllSettingTrackers(); + localSPKIDataTracker = param != null; + + this.localSPKIData=param; + + + } + + + /** + * field for MgmtData + */ + + + protected java.lang.String localMgmtData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localMgmtDataTracker = false ; + + public boolean isMgmtDataSpecified(){ + return localMgmtDataTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getMgmtData(){ + return localMgmtData; + } + + + + /** + * Auto generated setter method + * @param param MgmtData + */ + public void setMgmtData(java.lang.String param){ + + clearAllSettingTrackers(); + localMgmtDataTracker = param != null; + + this.localMgmtData=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyInfoTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyInfoTypeChoice", + xmlWriter); + } + + + } + if (localKeyNameTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "KeyName", xmlWriter); + + + if (localKeyName==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("KeyName cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localKeyName); + + } + + xmlWriter.writeEndElement(); + } if (localKeyValueTracker){ + if (localKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("KeyValue cannot be null!!"); + } + localKeyValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyValue"), + xmlWriter); + } if (localRetrievalMethodTracker){ + if (localRetrievalMethod==null){ + throw new org.apache.axis2.databinding.ADBException("RetrievalMethod cannot be null!!"); + } + localRetrievalMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RetrievalMethod"), + xmlWriter); + } if (localX509DataTracker){ + if (localX509Data==null){ + throw new org.apache.axis2.databinding.ADBException("X509Data cannot be null!!"); + } + localX509Data.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Data"), + xmlWriter); + } if (localPGPDataTracker){ + if (localPGPData==null){ + throw new org.apache.axis2.databinding.ADBException("PGPData cannot be null!!"); + } + localPGPData.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPData"), + xmlWriter); + } if (localSPKIDataTracker){ + if (localSPKIData==null){ + throw new org.apache.axis2.databinding.ADBException("SPKIData cannot be null!!"); + } + localSPKIData.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKIData"), + xmlWriter); + } if (localMgmtDataTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "MgmtData", xmlWriter); + + + if (localMgmtData==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("MgmtData cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localMgmtData); + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localKeyNameTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyName")); + + if (localKeyName != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localKeyName)); + } else { + throw new org.apache.axis2.databinding.ADBException("KeyName cannot be null!!"); + } + } if (localKeyValueTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyValue")); + + + if (localKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("KeyValue cannot be null!!"); + } + elementList.add(localKeyValue); + } if (localRetrievalMethodTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "RetrievalMethod")); + + + if (localRetrievalMethod==null){ + throw new org.apache.axis2.databinding.ADBException("RetrievalMethod cannot be null!!"); + } + elementList.add(localRetrievalMethod); + } if (localX509DataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509Data")); + + + if (localX509Data==null){ + throw new org.apache.axis2.databinding.ADBException("X509Data cannot be null!!"); + } + elementList.add(localX509Data); + } if (localPGPDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPData")); + + + if (localPGPData==null){ + throw new org.apache.axis2.databinding.ADBException("PGPData cannot be null!!"); + } + elementList.add(localPGPData); + } if (localSPKIDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SPKIData")); + + + if (localSPKIData==null){ + throw new org.apache.axis2.databinding.ADBException("SPKIData cannot be null!!"); + } + elementList.add(localSPKIData); + } if (localMgmtDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "MgmtData")); + + if (localMgmtData != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMgmtData)); + } else { + throw new org.apache.axis2.databinding.ADBException("MgmtData cannot be null!!"); + } + } if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyInfoTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyInfoTypeChoice object = + new KeyInfoTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"KeyName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setKeyName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyValue").equals(reader.getName())){ + + object.setKeyValue(KeyValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RetrievalMethod").equals(reader.getName())){ + + object.setRetrievalMethod(RetrievalMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Data").equals(reader.getName())){ + + object.setX509Data(X509DataType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPData").equals(reader.getName())){ + + object.setPGPData(PGPDataType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKIData").equals(reader.getName())){ + + object.setSPKIData(SPKIDataType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","MgmtData").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"MgmtData" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setMgmtData( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname8 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder8 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname8); + object.setExtraElement(builder8.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class XMLContentType extends AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = XMLContentType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Space + * This was an Attribute! + */ + + + protected Space_type0 localSpace ; + + + /** + * Auto generated getter method + * @return Space_type0 + */ + public Space_type0 getSpace(){ + return localSpace; + } + + + + /** + * Auto generated setter method + * @param param Space + */ + public void setSpace(Space_type0 param){ + + this.localSpace=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":XMLContentType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "XMLContentType", + xmlWriter); + } + + + + if (localSpace != null){ + writeAttribute("http://www.w3.org/XML/1998/namespace", + "space", + localSpace.toString(), xmlWriter); + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContentType")); + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("http://www.w3.org/XML/1998/namespace","space")); + + attribList.add(localSpace.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static XMLContentType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + XMLContentType object = + new XMLContentType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"XMLContentType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (XMLContentType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "space" + java.lang.String tempAttribSpace = + + reader.getAttributeValue("http://www.w3.org/XML/1998/namespace","space"); + + if (tempAttribSpace!=null){ + java.lang.String content = tempAttribSpace; + + object.setSpace( + Space_type0.Factory.fromString(reader,tempAttribSpace)); + + } else { + + } + handledAttributes.add("space"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObject + */ + + + protected DataObject_type0 localDataObject ; + + + /** + * Auto generated getter method + * @return DataObject_type0 + */ + public DataObject_type0 getDataObject(){ + return localDataObject; + } + + + + /** + * Auto generated setter method + * @param param DataObject + */ + public void setDataObject(DataObject_type0 param){ + + this.localDataObject=param; + + + } + + + /** + * field for DataObjectInfoTypeChoice_type0 + */ + + + protected DataObjectInfoTypeChoice_type0 localDataObjectInfoTypeChoice_type0 ; + + + /** + * Auto generated getter method + * @return DataObjectInfoTypeChoice_type0 + */ + public DataObjectInfoTypeChoice_type0 getDataObjectInfoTypeChoice_type0(){ + return localDataObjectInfoTypeChoice_type0; + } + + + + /** + * Auto generated setter method + * @param param DataObjectInfoTypeChoice_type0 + */ + public void setDataObjectInfoTypeChoice_type0(DataObjectInfoTypeChoice_type0 param){ + + this.localDataObjectInfoTypeChoice_type0=param; + + + } + + + /** + * field for Structure + * This was an Attribute! + */ + + + protected Structure_type0 localStructure ; + + + /** + * Auto generated getter method + * @return Structure_type0 + */ + public Structure_type0 getStructure(){ + return localStructure; + } + + + + /** + * Auto generated setter method + * @param param Structure + */ + public void setStructure(Structure_type0 param){ + + this.localStructure=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfoType", + xmlWriter); + } + + + } + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + localDataObjectInfoTypeChoice_type0.serialize(null,xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfoTypeChoice_type0")); + + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + elementList.add(localDataObjectInfoTypeChoice_type0); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfoType object = + new DataObjectInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObjectInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObjectInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type0.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + object.setDataObjectInfoTypeChoice_type0(DataObjectInfoTypeChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateCMSSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateCMSSignatureResponseTypeChoice + * This was an Array! + */ + + + protected CreateCMSSignatureResponseTypeChoice[] localCreateCMSSignatureResponseTypeChoice ; + + + /** + * Auto generated getter method + * @return CreateCMSSignatureResponseTypeChoice[] + */ + public CreateCMSSignatureResponseTypeChoice[] getCreateCMSSignatureResponseTypeChoice(){ + return localCreateCMSSignatureResponseTypeChoice; + } + + + + + + + /** + * validate the array for CreateCMSSignatureResponseTypeChoice + */ + protected void validateCreateCMSSignatureResponseTypeChoice(CreateCMSSignatureResponseTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param CreateCMSSignatureResponseTypeChoice + */ + public void setCreateCMSSignatureResponseTypeChoice(CreateCMSSignatureResponseTypeChoice[] param){ + + validateCreateCMSSignatureResponseTypeChoice(param); + + + this.localCreateCMSSignatureResponseTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param CreateCMSSignatureResponseTypeChoice + */ + public void addCreateCMSSignatureResponseTypeChoice(CreateCMSSignatureResponseTypeChoice param){ + if (localCreateCMSSignatureResponseTypeChoice == null){ + localCreateCMSSignatureResponseTypeChoice = new CreateCMSSignatureResponseTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localCreateCMSSignatureResponseTypeChoice); + list.add(param); + this.localCreateCMSSignatureResponseTypeChoice = + (CreateCMSSignatureResponseTypeChoice[])list.toArray( + new CreateCMSSignatureResponseTypeChoice[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureResponseType", + xmlWriter); + } + + + } + + + if (localCreateCMSSignatureResponseTypeChoice!=null){ + for (int i = 0;i < localCreateCMSSignatureResponseTypeChoice.length;i++){ + if (localCreateCMSSignatureResponseTypeChoice[i] != null){ + localCreateCMSSignatureResponseTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localCreateCMSSignatureResponseTypeChoice!=null) { + for (int i = 0;i < localCreateCMSSignatureResponseTypeChoice.length;i++){ + + if (localCreateCMSSignatureResponseTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateCMSSignatureResponseTypeChoice")); + elementList.add(localCreateCMSSignatureResponseTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureResponseType object = + new CreateCMSSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateCMSSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateCMSSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(CreateCMSSignatureResponseTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(CreateCMSSignatureResponseTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setCreateCMSSignatureResponseTypeChoice((CreateCMSSignatureResponseTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + CreateCMSSignatureResponseTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PGPDataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PGPDataType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localPGPDataTypeSequence_type0Tracker = false; + + localPGPDataTypeSequence_type1Tracker = false; + + } + + + /** + * field for PGPDataTypeSequence_type0 + */ + + + protected PGPDataTypeSequence_type0 localPGPDataTypeSequence_type0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPDataTypeSequence_type0Tracker = false ; + + public boolean isPGPDataTypeSequence_type0Specified(){ + return localPGPDataTypeSequence_type0Tracker; + } + + + + /** + * Auto generated getter method + * @return PGPDataTypeSequence_type0 + */ + public PGPDataTypeSequence_type0 getPGPDataTypeSequence_type0(){ + return localPGPDataTypeSequence_type0; + } + + + + /** + * Auto generated setter method + * @param param PGPDataTypeSequence_type0 + */ + public void setPGPDataTypeSequence_type0(PGPDataTypeSequence_type0 param){ + + clearAllSettingTrackers(); + localPGPDataTypeSequence_type0Tracker = param != null; + + this.localPGPDataTypeSequence_type0=param; + + + } + + + /** + * field for PGPDataTypeSequence_type1 + */ + + + protected PGPDataTypeSequence_type1 localPGPDataTypeSequence_type1 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPDataTypeSequence_type1Tracker = false ; + + public boolean isPGPDataTypeSequence_type1Specified(){ + return localPGPDataTypeSequence_type1Tracker; + } + + + + /** + * Auto generated getter method + * @return PGPDataTypeSequence_type1 + */ + public PGPDataTypeSequence_type1 getPGPDataTypeSequence_type1(){ + return localPGPDataTypeSequence_type1; + } + + + + /** + * Auto generated setter method + * @param param PGPDataTypeSequence_type1 + */ + public void setPGPDataTypeSequence_type1(PGPDataTypeSequence_type1 param){ + + clearAllSettingTrackers(); + localPGPDataTypeSequence_type1Tracker = param != null; + + this.localPGPDataTypeSequence_type1=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PGPDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PGPDataType", + xmlWriter); + } + + + } + if (localPGPDataTypeSequence_type0Tracker){ + if (localPGPDataTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type0 cannot be null!!"); + } + localPGPDataTypeSequence_type0.serialize(null,xmlWriter); + } if (localPGPDataTypeSequence_type1Tracker){ + if (localPGPDataTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type1 cannot be null!!"); + } + localPGPDataTypeSequence_type1.serialize(null,xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localPGPDataTypeSequence_type0Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPDataTypeSequence_type0")); + + + if (localPGPDataTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type0 cannot be null!!"); + } + elementList.add(localPGPDataTypeSequence_type0); + } if (localPGPDataTypeSequence_type1Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPDataTypeSequence_type1")); + + + if (localPGPDataTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type1 cannot be null!!"); + } + elementList.add(localPGPDataTypeSequence_type1); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPDataType object = + new PGPDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"PGPDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (PGPDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setPGPDataTypeSequence_type0(PGPDataTypeSequence_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + + } catch (java.lang.Exception e) {} + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setPGPDataTypeSequence_type1(PGPDataTypeSequence_type1.Factory.parse(reader)); + + } // End of if for expected property start element + + + } catch (java.lang.Exception e) {} + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Manifest + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Manifest", + "ns1"); + + + + /** + * field for Manifest + */ + + + protected ManifestType localManifest ; + + + /** + * Auto generated getter method + * @return ManifestType + */ + public ManifestType getManifest(){ + return localManifest; + } + + + + /** + * Auto generated setter method + * @param param Manifest + */ + public void setManifest(ManifestType param){ + + this.localManifest=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localManifest==null){ + throw new org.apache.axis2.databinding.ADBException("Manifest cannot be null!"); + } + localManifest.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localManifest.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Manifest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Manifest object = + new Manifest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Manifest").equals(reader.getName())){ + + object.setManifest(ManifestType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Transforms + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Transforms", + "ns1"); + + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + + this.localTransforms=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!"); + } + localTransforms.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localTransforms.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Transforms parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Transforms object = + new Transforms(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class FinalDataMetaInfoType extends MetaInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = FinalDataMetaInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Type + */ + + + protected org.apache.axis2.databinding.types.URI localType ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTypeTracker = false ; + + public boolean isTypeSpecified(){ + return localTypeTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getType(){ + return localType; + } + + + + /** + * Auto generated setter method + * @param param Type + */ + public void setType(org.apache.axis2.databinding.types.URI param){ + localTypeTracker = param != null; + + this.localType=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":FinalDataMetaInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "FinalDataMetaInfoType", + xmlWriter); + } + + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + localMimeType.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType"), + xmlWriter); + if (localDescriptionTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Description", xmlWriter); + + + if (localDescription==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localTypeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Type", xmlWriter); + + + if (localType==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Type cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FinalDataMetaInfoType")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MimeType")); + + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + elementList.add(localMimeType); + if (localDescriptionTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Description")); + + if (localDescription != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + } else { + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + } + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localTypeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Type")); + + if (localType != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + } else { + throw new org.apache.axis2.databinding.ADBException("Type cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static FinalDataMetaInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + FinalDataMetaInfoType object = + new FinalDataMetaInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"FinalDataMetaInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (FinalDataMetaInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType").equals(reader.getName())){ + + object.setMimeType(MimeTypeType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Description").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Description" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDescription( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone3=false; + + while (!loopDone3){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list3.add(builder3.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone3 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone3 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list3)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Type").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Type" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SignedInfo + */ + + + protected SignedInfoType localSignedInfo ; + + + /** + * Auto generated getter method + * @return SignedInfoType + */ + public SignedInfoType getSignedInfo(){ + return localSignedInfo; + } + + + + /** + * Auto generated setter method + * @param param SignedInfo + */ + public void setSignedInfo(SignedInfoType param){ + + this.localSignedInfo=param; + + + } + + + /** + * field for SignatureValue + */ + + + protected SignatureValueType localSignatureValue ; + + + /** + * Auto generated getter method + * @return SignatureValueType + */ + public SignatureValueType getSignatureValue(){ + return localSignatureValue; + } + + + + /** + * Auto generated setter method + * @param param SignatureValue + */ + public void setSignatureValue(SignatureValueType param){ + + this.localSignatureValue=param; + + + } + + + /** + * field for KeyInfo + */ + + + protected KeyInfoType localKeyInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localKeyInfoTracker = false ; + + public boolean isKeyInfoSpecified(){ + return localKeyInfoTracker; + } + + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getKeyInfo(){ + return localKeyInfo; + } + + + + /** + * Auto generated setter method + * @param param KeyInfo + */ + public void setKeyInfo(KeyInfoType param){ + localKeyInfoTracker = param != null; + + this.localKeyInfo=param; + + + } + + + /** + * field for Object + * This was an Array! + */ + + + protected ObjectType[] localObject ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localObjectTracker = false ; + + public boolean isObjectSpecified(){ + return localObjectTracker; + } + + + + /** + * Auto generated getter method + * @return ObjectType[] + */ + public ObjectType[] getObject(){ + return localObject; + } + + + + + + + /** + * validate the array for Object + */ + protected void validateObject(ObjectType[] param){ + + } + + + /** + * Auto generated setter method + * @param param Object + */ + public void setObject(ObjectType[] param){ + + validateObject(param); + + localObjectTracker = param != null; + + this.localObject=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ObjectType + */ + public void addObject(ObjectType param){ + if (localObject == null){ + localObject = new ObjectType[]{}; + } + + + //update the setting tracker + localObjectTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localObject); + list.add(param); + this.localObject = + (ObjectType[])list.toArray( + new ObjectType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localSignedInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignedInfo cannot be null!!"); + } + localSignedInfo.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignedInfo"), + xmlWriter); + + if (localSignatureValue==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureValue cannot be null!!"); + } + localSignatureValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureValue"), + xmlWriter); + if (localKeyInfoTracker){ + if (localKeyInfo==null){ + throw new org.apache.axis2.databinding.ADBException("KeyInfo cannot be null!!"); + } + localKeyInfo.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyInfo"), + xmlWriter); + } if (localObjectTracker){ + if (localObject!=null){ + for (int i = 0;i < localObject.length;i++){ + if (localObject[i] != null){ + localObject[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Object cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignedInfo")); + + + if (localSignedInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignedInfo cannot be null!!"); + } + elementList.add(localSignedInfo); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignatureValue")); + + + if (localSignatureValue==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureValue cannot be null!!"); + } + elementList.add(localSignatureValue); + if (localKeyInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyInfo")); + + + if (localKeyInfo==null){ + throw new org.apache.axis2.databinding.ADBException("KeyInfo cannot be null!!"); + } + elementList.add(localKeyInfo); + } if (localObjectTracker){ + if (localObject!=null) { + for (int i = 0;i < localObject.length;i++){ + + if (localObject[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Object")); + elementList.add(localObject[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Object cannot be null!!"); + + } + + } + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureType object = + new SignatureType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list4 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignedInfo").equals(reader.getName())){ + + object.setSignedInfo(SignedInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureValue").equals(reader.getName())){ + + object.setSignatureValue(SignatureValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyInfo").equals(reader.getName())){ + + object.setKeyInfo(KeyInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list4.add(ObjectType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone4 = false; + while(!loopDone4){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone4 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object").equals(reader.getName())){ + list4.add(ObjectType.Factory.parse(reader)); + + }else{ + loopDone4 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setObject((ObjectType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ObjectType.class, + list4)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PGPDataTypeSequence_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PGPDataTypeSequence_type0 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for PGPKeyID + */ + + + protected javax.activation.DataHandler localPGPKeyID ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getPGPKeyID(){ + return localPGPKeyID; + } + + + + /** + * Auto generated setter method + * @param param PGPKeyID + */ + public void setPGPKeyID(javax.activation.DataHandler param){ + + this.localPGPKeyID=param; + + + } + + + /** + * field for PGPKeyPacket + */ + + + protected javax.activation.DataHandler localPGPKeyPacket ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPKeyPacketTracker = false ; + + public boolean isPGPKeyPacketSpecified(){ + return localPGPKeyPacketTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getPGPKeyPacket(){ + return localPGPKeyPacket; + } + + + + /** + * Auto generated setter method + * @param param PGPKeyPacket + */ + public void setPGPKeyPacket(javax.activation.DataHandler param){ + localPGPKeyPacketTracker = param != null; + + this.localPGPKeyPacket=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PGPDataTypeSequence_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PGPDataTypeSequence_type0", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "PGPKeyID", xmlWriter); + + + if (localPGPKeyID!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localPGPKeyID, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for PGPKeyID", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localPGPKeyPacketTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "PGPKeyPacket", xmlWriter); + + + if (localPGPKeyPacket!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localPGPKeyPacket, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for PGPKeyPacket", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPKeyID")); + + elementList.add(localPGPKeyID); + if (localPGPKeyPacketTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPKeyPacket")); + + elementList.add(localPGPKeyPacket); + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPDataTypeSequence_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPDataTypeSequence_type0 object = + new PGPDataTypeSequence_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPKeyID").equals(reader.getName())){ + + object.setPGPKeyID(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPKeyPacket").equals(reader.getName())){ + + object.setPGPKeyPacket(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone3=false; + + while (!loopDone3){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list3.add(builder3.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone3 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone3 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list3)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PGPDataTypeSequence_type1 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PGPDataTypeSequence_type1 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for PGPKeyPacket + */ + + + protected javax.activation.DataHandler localPGPKeyPacket ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getPGPKeyPacket(){ + return localPGPKeyPacket; + } + + + + /** + * Auto generated setter method + * @param param PGPKeyPacket + */ + public void setPGPKeyPacket(javax.activation.DataHandler param){ + + this.localPGPKeyPacket=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PGPDataTypeSequence_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PGPDataTypeSequence_type1", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "PGPKeyPacket", xmlWriter); + + + if (localPGPKeyPacket!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localPGPKeyPacket, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for PGPKeyPacket", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPKeyPacket")); + + elementList.add(localPGPKeyPacket); + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPDataTypeSequence_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPDataTypeSequence_type1 object = + new PGPDataTypeSequence_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPKeyPacket").equals(reader.getName())){ + + object.setPGPKeyPacket(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone2=false; + + while (!loopDone2){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder2 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list2.add(builder2.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone2 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone2 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureResponseTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateXMLSignatureResponseTypeChoice + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localSignatureEnvironmentTracker = false; + + localErrorResponseTracker = false; + + } + + + /** + * field for SignatureEnvironment + */ + + + protected SignatureEnvironment_type0 localSignatureEnvironment ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSignatureEnvironmentTracker = false ; + + public boolean isSignatureEnvironmentSpecified(){ + return localSignatureEnvironmentTracker; + } + + + + /** + * Auto generated getter method + * @return SignatureEnvironment_type0 + */ + public SignatureEnvironment_type0 getSignatureEnvironment(){ + return localSignatureEnvironment; + } + + + + /** + * Auto generated setter method + * @param param SignatureEnvironment + */ + public void setSignatureEnvironment(SignatureEnvironment_type0 param){ + + clearAllSettingTrackers(); + localSignatureEnvironmentTracker = param != null; + + this.localSignatureEnvironment=param; + + + } + + + /** + * field for ErrorResponse + */ + + + protected ErrorResponseType localErrorResponse ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localErrorResponseTracker = false ; + + public boolean isErrorResponseSpecified(){ + return localErrorResponseTracker; + } + + + + /** + * Auto generated getter method + * @return ErrorResponseType + */ + public ErrorResponseType getErrorResponse(){ + return localErrorResponse; + } + + + + /** + * Auto generated setter method + * @param param ErrorResponse + */ + public void setErrorResponse(ErrorResponseType param){ + + clearAllSettingTrackers(); + localErrorResponseTracker = param != null; + + this.localErrorResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureResponseTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureResponseTypeChoice", + xmlWriter); + } + + + } + if (localSignatureEnvironmentTracker){ + if (localSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureEnvironment cannot be null!!"); + } + localSignatureEnvironment.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureEnvironment"), + xmlWriter); + } if (localErrorResponseTracker){ + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + localErrorResponse.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localSignatureEnvironmentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureEnvironment")); + + + if (localSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureEnvironment cannot be null!!"); + } + elementList.add(localSignatureEnvironment); + } if (localErrorResponseTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorResponse")); + + + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + elementList.add(localErrorResponse); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureResponseTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureResponseTypeChoice object = + new CreateXMLSignatureResponseTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureEnvironment").equals(reader.getName())){ + + object.setSignatureEnvironment(SignatureEnvironment_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse").equals(reader.getName())){ + + object.setErrorResponse(ErrorResponseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentBaseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localXMLContentTracker = false; + + localLocRefContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for XMLContent + */ + + + protected XMLContentType localXMLContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLContentTracker = false ; + + public boolean isXMLContentSpecified(){ + return localXMLContentTracker; + } + + + + /** + * Auto generated getter method + * @return XMLContentType + */ + public XMLContentType getXMLContent(){ + return localXMLContent; + } + + + + /** + * Auto generated setter method + * @param param XMLContent + */ + public void setXMLContent(XMLContentType param){ + + clearAllSettingTrackers(); + localXMLContentTracker = param != null; + + this.localXMLContent=param; + + + } + + + /** + * field for LocRefContent + */ + + + protected org.apache.axis2.databinding.types.URI localLocRefContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localLocRefContentTracker = false ; + + public boolean isLocRefContentSpecified(){ + return localLocRefContentTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getLocRefContent(){ + return localLocRefContent; + } + + + + /** + * Auto generated setter method + * @param param LocRefContent + */ + public void setLocRefContent(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localLocRefContentTracker = param != null; + + this.localLocRefContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentBaseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentBaseType", + xmlWriter); + } + + + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localXMLContentTracker){ + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + } if (localLocRefContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localXMLContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + } if (localLocRefContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentBaseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentBaseType object = + new ContentBaseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentBaseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentBaseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureMethod", + "ns1"); + + + + /** + * field for SignatureMethod + */ + + + protected SignatureMethodType localSignatureMethod ; + + + /** + * Auto generated getter method + * @return SignatureMethodType + */ + public SignatureMethodType getSignatureMethod(){ + return localSignatureMethod; + } + + + + /** + * Auto generated setter method + * @param param SignatureMethod + */ + public void setSignatureMethod(SignatureMethodType param){ + + this.localSignatureMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureMethod==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureMethod cannot be null!"); + } + localSignatureMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureMethod object = + new SignatureMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureMethod").equals(reader.getName())){ + + object.setSignatureMethod(SignatureMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSDataObjectRequiredMetaType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSDataObjectRequiredMetaType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MetaInfo + */ + + + protected MetaInfoType localMetaInfo ; + + + /** + * Auto generated getter method + * @return MetaInfoType + */ + public MetaInfoType getMetaInfo(){ + return localMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param MetaInfo + */ + public void setMetaInfo(MetaInfoType param){ + + this.localMetaInfo=param; + + + } + + + /** + * field for Content + */ + + + protected CMSContentBaseType localContent ; + + + /** + * Auto generated getter method + * @return CMSContentBaseType + */ + public CMSContentBaseType getContent(){ + return localContent; + } + + + + /** + * Auto generated setter method + * @param param Content + */ + public void setContent(CMSContentBaseType param){ + + this.localContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSDataObjectRequiredMetaType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSDataObjectRequiredMetaType", + xmlWriter); + } + + + } + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSDataObjectRequiredMetaType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSDataObjectRequiredMetaType object = + new CMSDataObjectRequiredMetaType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSDataObjectRequiredMetaType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSDataObjectRequiredMetaType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(CMSContentBaseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyInfo + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "KeyInfo", + "ns1"); + + + + /** + * field for KeyInfo + */ + + + protected KeyInfoType localKeyInfo ; + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getKeyInfo(){ + return localKeyInfo; + } + + + + /** + * Auto generated setter method + * @param param KeyInfo + */ + public void setKeyInfo(KeyInfoType param){ + + this.localKeyInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localKeyInfo==null){ + throw new org.apache.axis2.databinding.ADBException("KeyInfo cannot be null!"); + } + localKeyInfo.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localKeyInfo.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyInfo parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyInfo object = + new KeyInfo(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyInfo").equals(reader.getName())){ + + object.setKeyInfo(KeyInfoType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509DataTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509DataTypeSequence + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for X509DataTypeChoice_type0 + */ + + + protected X509DataTypeChoice_type0 localX509DataTypeChoice_type0 ; + + + /** + * Auto generated getter method + * @return X509DataTypeChoice_type0 + */ + public X509DataTypeChoice_type0 getX509DataTypeChoice_type0(){ + return localX509DataTypeChoice_type0; + } + + + + /** + * Auto generated setter method + * @param param X509DataTypeChoice_type0 + */ + public void setX509DataTypeChoice_type0(X509DataTypeChoice_type0 param){ + + this.localX509DataTypeChoice_type0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509DataTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509DataTypeSequence", + xmlWriter); + } + + + } + + if (localX509DataTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("X509DataTypeChoice_type0 cannot be null!!"); + } + localX509DataTypeChoice_type0.serialize(null,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509DataTypeChoice_type0")); + + + if (localX509DataTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("X509DataTypeChoice_type0 cannot be null!!"); + } + elementList.add(localX509DataTypeChoice_type0); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509DataTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509DataTypeSequence object = + new X509DataTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + object.setX509DataTypeChoice_type0(X509DataTypeChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ObjectTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ObjectTypeSequence + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ObjectTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ObjectTypeSequence", + xmlWriter); + } + + + } + + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ObjectTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ObjectTypeSequence object = + new ObjectTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DigestMethod", + "ns1"); + + + + /** + * field for DigestMethod + */ + + + protected DigestMethodType localDigestMethod ; + + + /** + * Auto generated getter method + * @return DigestMethodType + */ + public DigestMethodType getDigestMethod(){ + return localDigestMethod; + } + + + + /** + * Auto generated setter method + * @param param DigestMethod + */ + public void setDigestMethod(DigestMethodType param){ + + this.localDigestMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!"); + } + localDigestMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localDigestMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestMethod object = + new DigestMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod").equals(reader.getName())){ + + object.setDigestMethod(DigestMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ReferencesCheckResultInfoType extends AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ReferencesCheckResultInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for FailedReference + * This was an Array! + */ + + + protected org.apache.axis2.databinding.types.PositiveInteger[] localFailedReference ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localFailedReferenceTracker = false ; + + public boolean isFailedReferenceSpecified(){ + return localFailedReferenceTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.PositiveInteger[] + */ + public org.apache.axis2.databinding.types.PositiveInteger[] getFailedReference(){ + return localFailedReference; + } + + + + + + + /** + * validate the array for FailedReference + */ + protected void validateFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + } + + + /** + * Auto generated setter method + * @param param FailedReference + */ + public void setFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + validateFailedReference(param); + + localFailedReferenceTracker = param != null; + + this.localFailedReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axis2.databinding.types.PositiveInteger + */ + public void addFailedReference(org.apache.axis2.databinding.types.PositiveInteger param){ + if (localFailedReference == null){ + localFailedReference = new org.apache.axis2.databinding.types.PositiveInteger[]{}; + } + + + //update the setting tracker + localFailedReferenceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localFailedReference); + list.add(param); + this.localFailedReference = + (org.apache.axis2.databinding.types.PositiveInteger[])list.toArray( + new org.apache.axis2.databinding.types.PositiveInteger[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ReferencesCheckResultInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ReferencesCheckResultInfoType", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null) { + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + + writeStartElement(null, namespace, "FailedReference", xmlWriter); + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + + xmlWriter.writeEndElement(); + + } else { + + // we have to do nothing since minOccurs is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null){ + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "FailedReference")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + } else { + + // have to do nothing + + } + + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ReferencesCheckResultInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ReferencesCheckResultInfoType object = + new ReferencesCheckResultInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ReferencesCheckResultInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ReferencesCheckResultInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(reader.getElementText()); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // Ensure we are at the EndElement + while (!reader.isEndElement()){ + reader.next(); + } + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + list2.add(reader.getElementText()); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setFailedReference((org.apache.axis2.databinding.types.PositiveInteger[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axis2.databinding.types.PositiveInteger.class,list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class MgmtData + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "MgmtData", + "ns1"); + + + + /** + * field for MgmtData + */ + + + protected java.lang.String localMgmtData ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getMgmtData(){ + return localMgmtData; + } + + + + /** + * Auto generated setter method + * @param param MgmtData + */ + public void setMgmtData(java.lang.String param){ + + this.localMgmtData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = "http://www.w3.org/2000/09/xmldsig#"; + java.lang.String _localName = "MgmtData"; + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":MgmtData", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "MgmtData", + xmlWriter); + } + } + + if (localMgmtData==null){ + + throw new org.apache.axis2.databinding.ADBException("MgmtData cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localMgmtData); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMgmtData) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static MgmtData parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + MgmtData object = + new MgmtData(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","MgmtData").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"MgmtData" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setMgmtData( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObject_type1 extends CMSDataObjectRequiredMetaType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObject_type1 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObject_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObject_type1", + xmlWriter); + } + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject_type1")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObject_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObject_type1 object = + new DataObject_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObject_type1".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObject_type1)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(CMSContentBaseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureResponseTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateCMSSignatureResponseTypeChoice + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localCMSSignatureTracker = false; + + localErrorResponseTracker = false; + + } + + + /** + * field for CMSSignature + */ + + + protected javax.activation.DataHandler localCMSSignature ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCMSSignatureTracker = false ; + + public boolean isCMSSignatureSpecified(){ + return localCMSSignatureTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getCMSSignature(){ + return localCMSSignature; + } + + + + /** + * Auto generated setter method + * @param param CMSSignature + */ + public void setCMSSignature(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localCMSSignatureTracker = param != null; + + this.localCMSSignature=param; + + + } + + + /** + * field for ErrorResponse + */ + + + protected ErrorResponseType localErrorResponse ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localErrorResponseTracker = false ; + + public boolean isErrorResponseSpecified(){ + return localErrorResponseTracker; + } + + + + /** + * Auto generated getter method + * @return ErrorResponseType + */ + public ErrorResponseType getErrorResponse(){ + return localErrorResponse; + } + + + + /** + * Auto generated setter method + * @param param ErrorResponse + */ + public void setErrorResponse(ErrorResponseType param){ + + clearAllSettingTrackers(); + localErrorResponseTracker = param != null; + + this.localErrorResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureResponseTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureResponseTypeChoice", + xmlWriter); + } + + + } + if (localCMSSignatureTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "CMSSignature", xmlWriter); + + + if (localCMSSignature!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localCMSSignature, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for CMSSignature", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localErrorResponseTracker){ + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + localErrorResponse.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCMSSignatureTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CMSSignature")); + + elementList.add(localCMSSignature); + } if (localErrorResponseTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorResponse")); + + + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + elementList.add(localErrorResponse); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureResponseTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureResponseTypeChoice object = + new CreateCMSSignatureResponseTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CMSSignature").equals(reader.getName())){ + + object.setCMSSignature(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse").equals(reader.getName())){ + + object.setErrorResponse(ErrorResponseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObject_type0 extends ContentOptionalRefType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObject_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObject_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObject_type0", + xmlWriter); + } + + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject_type0")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObject_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObject_type0 object = + new DataObject_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObject_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObject_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSContentBaseType extends ContentOptionalRefType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSContentBaseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * Auto generated getter method + * Overridden from ContentOptionalRefType + * + * @throws RuntimeException + */ + public org.apache.axis2.databinding.types.URI getReference(){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + /** + * Auto generated setter method + * Overridden from ContentOptionalRefType + * + * @param param Reference + * @throws RuntimeException + */ + public void setReference(org.apache.axis2.databinding.types.URI param){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSContentBaseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSContentBaseType", + xmlWriter); + } + + + } + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSContentBaseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSContentBaseType object = + new CMSContentBaseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSContentBaseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSContentBaseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class QualifiedCertificate + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "QualifiedCertificate", + "ns2"); + + + + /** + * field for Source + * This was an Attribute! + */ + + + protected Source_type1 localSource ; + + + /** + * Auto generated getter method + * @return Source_type1 + */ + public Source_type1 getSource(){ + return localSource; + } + + + + /** + * Auto generated setter method + * @param param Source + */ + public void setSource(Source_type1 param){ + + this.localSource=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":QualifiedCertificate", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "QualifiedCertificate", + xmlWriter); + } + + + } + + + if (localSource != null){ + writeAttribute("", + "source", + localSource.toString(), xmlWriter); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add( + new javax.xml.namespace.QName("","source")); + + attribList.add(localSource.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static QualifiedCertificate parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + QualifiedCertificate object = + new QualifiedCertificate(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"QualifiedCertificate".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (QualifiedCertificate)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "source" + java.lang.String tempAttribSource = + + reader.getAttributeValue(null,"source"); + + if (tempAttribSource!=null){ + java.lang.String content = tempAttribSource; + + object.setSource( + Source_type1.Factory.fromString(reader,tempAttribSource)); + + } else { + + } + handledAttributes.add("source"); + + + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignaturePropertiesType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignaturePropertiesType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SignatureProperty + * This was an Array! + */ + + + protected SignaturePropertyType[] localSignatureProperty ; + + + /** + * Auto generated getter method + * @return SignaturePropertyType[] + */ + public SignaturePropertyType[] getSignatureProperty(){ + return localSignatureProperty; + } + + + + + + + /** + * validate the array for SignatureProperty + */ + protected void validateSignatureProperty(SignaturePropertyType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SignatureProperty + */ + public void setSignatureProperty(SignaturePropertyType[] param){ + + validateSignatureProperty(param); + + + this.localSignatureProperty=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SignaturePropertyType + */ + public void addSignatureProperty(SignaturePropertyType param){ + if (localSignatureProperty == null){ + localSignatureProperty = new SignaturePropertyType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSignatureProperty); + list.add(param); + this.localSignatureProperty = + (SignaturePropertyType[])list.toArray( + new SignaturePropertyType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignaturePropertiesType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignaturePropertiesType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localSignatureProperty!=null){ + for (int i = 0;i < localSignatureProperty.length;i++){ + if (localSignatureProperty[i] != null){ + localSignatureProperty[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localSignatureProperty!=null) { + for (int i = 0;i < localSignatureProperty.length;i++){ + + if (localSignatureProperty[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignatureProperty")); + elementList.add(localSignatureProperty[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignaturePropertiesType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignaturePropertiesType object = + new SignaturePropertiesType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignaturePropertiesType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignaturePropertiesType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(SignaturePropertyType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty").equals(reader.getName())){ + list1.add(SignaturePropertyType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSignatureProperty((SignaturePropertyType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SignaturePropertyType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatoriesType extends org.apache.axis2.databinding.types.Union + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatoriesType", + "ns2"); + + + + + public void setObject(java.lang.Object object){ + + if (object instanceof AllSignatoriesType){ + this.localObject = object; + + } else { + throw new java.lang.RuntimeException("Invalid object type"); + } + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + writeStartElement(null, parentQName.getNamespaceURI(), parentQName.getLocalPart(), xmlWriter); + + + if (localObject instanceof AllSignatoriesType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":AllSignatoriesType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "AllSignatoriesType", + xmlWriter); + } + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString((AllSignatoriesType)localObject)); + + } else { + throw new org.apache.axis2.databinding.ADBException("Invalid object type"); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + localObject.toString() + }, + null); + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + public static SignatoriesType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String namespaceURI, + java.lang.String type) throws org.apache.axis2.databinding.ADBException { + + SignatoriesType object = null; + try { + if ("http://www.w3.org/2001/XMLSchema".equals(namespaceURI)) { + object = new SignatoriesType(); + object.setObject(xmlStreamReader, namespaceURI, type); + } else { + object = new SignatoriesType(); + object.setObject(ExtensionMapper.getTypeObject(namespaceURI, type, xmlStreamReader)); + } + return object; + } catch (java.lang.Exception e) { + throw new org.apache.axis2.databinding.ADBException("Error in parsing value"); + } + } + + public static SignatoriesType fromString(java.lang.String value, + java.lang.String namespaceURI){ + SignatoriesType object = new SignatoriesType(); + boolean isValueSet = false; + + // we have to set the object with the first matching type. + if (!isValueSet) { + + try { + object.setObject(AllSignatoriesType.Factory.fromString(value, namespaceURI)); + isValueSet = true; + } catch (java.lang.Exception e) { + } + + } + + return object; + } + + public static SignatoriesType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return SignatoriesType.Factory.fromString(content,namespaceUri); + } else { + return SignatoriesType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatoriesType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatoriesType object = + new SignatoriesType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + object = SignatoriesType.Factory.fromString(reader,nsUri,type); + + + } + + } else { + // i.e this is an union type with out specific xsi:type + java.lang.String content = reader.getElementText(); + if (content.indexOf(":") > -1){ + // i.e. this could be a qname + prefix = content.substring(0,content.indexOf(":")); + namespaceuri = reader.getNamespaceContext().getNamespaceURI(prefix); + object = SignatoriesType.Factory.fromString(content,namespaceuri); + } else { + object = SignatoriesType.Factory.fromString(content,""); + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureRequest + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyXMLSignatureRequest", + "ns2"); + + + + /** + * field for VerifyXMLSignatureRequest + */ + + + protected VerifyXMLSignatureRequestType localVerifyXMLSignatureRequest ; + + + /** + * Auto generated getter method + * @return VerifyXMLSignatureRequestType + */ + public VerifyXMLSignatureRequestType getVerifyXMLSignatureRequest(){ + return localVerifyXMLSignatureRequest; + } + + + + /** + * Auto generated setter method + * @param param VerifyXMLSignatureRequest + */ + public void setVerifyXMLSignatureRequest(VerifyXMLSignatureRequestType param){ + + this.localVerifyXMLSignatureRequest=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyXMLSignatureRequest==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureRequest cannot be null!"); + } + localVerifyXMLSignatureRequest.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyXMLSignatureRequest.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureRequest object = + new VerifyXMLSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyXMLSignatureRequest").equals(reader.getName())){ + + object.setVerifyXMLSignatureRequest(VerifyXMLSignatureRequestType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DSAKeyValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for DSAKeyValueTypeSequence_type0 + */ + + + protected DSAKeyValueTypeSequence_type0 localDSAKeyValueTypeSequence_type0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDSAKeyValueTypeSequence_type0Tracker = false ; + + public boolean isDSAKeyValueTypeSequence_type0Specified(){ + return localDSAKeyValueTypeSequence_type0Tracker; + } + + + + /** + * Auto generated getter method + * @return DSAKeyValueTypeSequence_type0 + */ + public DSAKeyValueTypeSequence_type0 getDSAKeyValueTypeSequence_type0(){ + return localDSAKeyValueTypeSequence_type0; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValueTypeSequence_type0 + */ + public void setDSAKeyValueTypeSequence_type0(DSAKeyValueTypeSequence_type0 param){ + localDSAKeyValueTypeSequence_type0Tracker = param != null; + + this.localDSAKeyValueTypeSequence_type0=param; + + + } + + + /** + * field for G + */ + + + protected CryptoBinary localG ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localGTracker = false ; + + public boolean isGSpecified(){ + return localGTracker; + } + + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getG(){ + return localG; + } + + + + /** + * Auto generated setter method + * @param param G + */ + public void setG(CryptoBinary param){ + localGTracker = param != null; + + this.localG=param; + + + } + + + /** + * field for Y + */ + + + protected CryptoBinary localY ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getY(){ + return localY; + } + + + + /** + * Auto generated setter method + * @param param Y + */ + public void setY(CryptoBinary param){ + + this.localY=param; + + + } + + + /** + * field for J + */ + + + protected CryptoBinary localJ ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localJTracker = false ; + + public boolean isJSpecified(){ + return localJTracker; + } + + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getJ(){ + return localJ; + } + + + + /** + * Auto generated setter method + * @param param J + */ + public void setJ(CryptoBinary param){ + localJTracker = param != null; + + this.localJ=param; + + + } + + + /** + * field for DSAKeyValueTypeSequence_type1 + */ + + + protected DSAKeyValueTypeSequence_type1 localDSAKeyValueTypeSequence_type1 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDSAKeyValueTypeSequence_type1Tracker = false ; + + public boolean isDSAKeyValueTypeSequence_type1Specified(){ + return localDSAKeyValueTypeSequence_type1Tracker; + } + + + + /** + * Auto generated getter method + * @return DSAKeyValueTypeSequence_type1 + */ + public DSAKeyValueTypeSequence_type1 getDSAKeyValueTypeSequence_type1(){ + return localDSAKeyValueTypeSequence_type1; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValueTypeSequence_type1 + */ + public void setDSAKeyValueTypeSequence_type1(DSAKeyValueTypeSequence_type1 param){ + localDSAKeyValueTypeSequence_type1Tracker = param != null; + + this.localDSAKeyValueTypeSequence_type1=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DSAKeyValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DSAKeyValueType", + xmlWriter); + } + + + } + if (localDSAKeyValueTypeSequence_type0Tracker){ + if (localDSAKeyValueTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type0 cannot be null!!"); + } + localDSAKeyValueTypeSequence_type0.serialize(null,xmlWriter); + } if (localGTracker){ + if (localG==null){ + throw new org.apache.axis2.databinding.ADBException("G cannot be null!!"); + } + localG.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","G"), + xmlWriter); + } + if (localY==null){ + throw new org.apache.axis2.databinding.ADBException("Y cannot be null!!"); + } + localY.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Y"), + xmlWriter); + if (localJTracker){ + if (localJ==null){ + throw new org.apache.axis2.databinding.ADBException("J cannot be null!!"); + } + localJ.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","J"), + xmlWriter); + } if (localDSAKeyValueTypeSequence_type1Tracker){ + if (localDSAKeyValueTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type1 cannot be null!!"); + } + localDSAKeyValueTypeSequence_type1.serialize(null,xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDSAKeyValueTypeSequence_type0Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValueTypeSequence_type0")); + + + if (localDSAKeyValueTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type0 cannot be null!!"); + } + elementList.add(localDSAKeyValueTypeSequence_type0); + } if (localGTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "G")); + + + if (localG==null){ + throw new org.apache.axis2.databinding.ADBException("G cannot be null!!"); + } + elementList.add(localG); + } + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Y")); + + + if (localY==null){ + throw new org.apache.axis2.databinding.ADBException("Y cannot be null!!"); + } + elementList.add(localY); + if (localJTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "J")); + + + if (localJ==null){ + throw new org.apache.axis2.databinding.ADBException("J cannot be null!!"); + } + elementList.add(localJ); + } if (localDSAKeyValueTypeSequence_type1Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValueTypeSequence_type1")); + + + if (localDSAKeyValueTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type1 cannot be null!!"); + } + elementList.add(localDSAKeyValueTypeSequence_type1); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValueType object = + new DSAKeyValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DSAKeyValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DSAKeyValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setDSAKeyValueTypeSequence_type0(DSAKeyValueTypeSequence_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","G").equals(reader.getName())){ + + object.setG(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Y").equals(reader.getName())){ + + object.setY(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","J").equals(reader.getName())){ + + object.setJ(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setDSAKeyValueTypeSequence_type1(DSAKeyValueTypeSequence_type1.Factory.parse(reader)); + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509IssuerSerialType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509IssuerSerialType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for X509IssuerName + */ + + + protected java.lang.String localX509IssuerName ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getX509IssuerName(){ + return localX509IssuerName; + } + + + + /** + * Auto generated setter method + * @param param X509IssuerName + */ + public void setX509IssuerName(java.lang.String param){ + + this.localX509IssuerName=param; + + + } + + + /** + * field for X509SerialNumber + */ + + + protected java.math.BigInteger localX509SerialNumber ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getX509SerialNumber(){ + return localX509SerialNumber; + } + + + + /** + * Auto generated setter method + * @param param X509SerialNumber + */ + public void setX509SerialNumber(java.math.BigInteger param){ + + this.localX509SerialNumber=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509IssuerSerialType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509IssuerSerialType", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509IssuerName", xmlWriter); + + + if (localX509IssuerName==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("X509IssuerName cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localX509IssuerName); + + } + + xmlWriter.writeEndElement(); + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509SerialNumber", xmlWriter); + + + if (localX509SerialNumber==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("X509SerialNumber cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509SerialNumber)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509IssuerName")); + + if (localX509IssuerName != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509IssuerName)); + } else { + throw new org.apache.axis2.databinding.ADBException("X509IssuerName cannot be null!!"); + } + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509SerialNumber")); + + if (localX509SerialNumber != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509SerialNumber)); + } else { + throw new org.apache.axis2.databinding.ADBException("X509SerialNumber cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509IssuerSerialType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509IssuerSerialType object = + new X509IssuerSerialType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"X509IssuerSerialType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (X509IssuerSerialType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509IssuerName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"X509IssuerName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setX509IssuerName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509SerialNumber").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"X509SerialNumber" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setX509SerialNumber( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignedInfo + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignedInfo", + "ns1"); + + + + /** + * field for SignedInfo + */ + + + protected SignedInfoType localSignedInfo ; + + + /** + * Auto generated getter method + * @return SignedInfoType + */ + public SignedInfoType getSignedInfo(){ + return localSignedInfo; + } + + + + /** + * Auto generated setter method + * @param param SignedInfo + */ + public void setSignedInfo(SignedInfoType param){ + + this.localSignedInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignedInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignedInfo cannot be null!"); + } + localSignedInfo.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignedInfo.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignedInfo parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignedInfo object = + new SignedInfo(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignedInfo").equals(reader.getName())){ + + object.setSignedInfo(SignedInfoType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureRequestTypeChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyXMLSignatureRequestTypeChoice_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localSupplementProfileTracker = false; + + localSupplementProfileIDTracker = false; + + } + + + /** + * field for SupplementProfile + */ + + + protected XMLDataObjectAssociationType localSupplementProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementProfileTracker = false ; + + public boolean isSupplementProfileSpecified(){ + return localSupplementProfileTracker; + } + + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType + */ + public XMLDataObjectAssociationType getSupplementProfile(){ + return localSupplementProfile; + } + + + + /** + * Auto generated setter method + * @param param SupplementProfile + */ + public void setSupplementProfile(XMLDataObjectAssociationType param){ + + clearAllSettingTrackers(); + localSupplementProfileTracker = param != null; + + this.localSupplementProfile=param; + + + } + + + /** + * field for SupplementProfileID + */ + + + protected java.lang.String localSupplementProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementProfileIDTracker = false ; + + public boolean isSupplementProfileIDSpecified(){ + return localSupplementProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getSupplementProfileID(){ + return localSupplementProfileID; + } + + + + /** + * Auto generated setter method + * @param param SupplementProfileID + */ + public void setSupplementProfileID(java.lang.String param){ + + clearAllSettingTrackers(); + localSupplementProfileIDTracker = param != null; + + this.localSupplementProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyXMLSignatureRequestTypeChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyXMLSignatureRequestTypeChoice_type0", + xmlWriter); + } + + + } + if (localSupplementProfileTracker){ + if (localSupplementProfile==null){ + throw new org.apache.axis2.databinding.ADBException("SupplementProfile cannot be null!!"); + } + localSupplementProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfile"), + xmlWriter); + } if (localSupplementProfileIDTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "SupplementProfileID", xmlWriter); + + + if (localSupplementProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("SupplementProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localSupplementProfileID); + + } + + xmlWriter.writeEndElement(); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localSupplementProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SupplementProfile")); + + + if (localSupplementProfile==null){ + throw new org.apache.axis2.databinding.ADBException("SupplementProfile cannot be null!!"); + } + elementList.add(localSupplementProfile); + } if (localSupplementProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SupplementProfileID")); + + if (localSupplementProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSupplementProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("SupplementProfileID cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureRequestTypeChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureRequestTypeChoice_type0 object = + new VerifyXMLSignatureRequestTypeChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfile").equals(reader.getName())){ + + object.setSupplementProfile(XMLDataObjectAssociationType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"SupplementProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setSupplementProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Object + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Object", + "ns1"); + + + + /** + * field for Object + */ + + + protected ObjectType localObject ; + + + /** + * Auto generated getter method + * @return ObjectType + */ + public ObjectType getObject(){ + return localObject; + } + + + + /** + * Auto generated setter method + * @param param Object + */ + public void setObject(ObjectType param){ + + this.localObject=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localObject==null){ + throw new org.apache.axis2.databinding.ADBException("Object cannot be null!"); + } + localObject.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localObject.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Object parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Object object = + new Object(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object").equals(reader.getName())){ + + object.setObject(ObjectType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = KeyValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localDSAKeyValueTracker = false; + + localRSAKeyValueTracker = false; + + localExtraElementTracker = false; + + } + + + /** + * field for DSAKeyValue + */ + + + protected DSAKeyValueType localDSAKeyValue ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDSAKeyValueTracker = false ; + + public boolean isDSAKeyValueSpecified(){ + return localDSAKeyValueTracker; + } + + + + /** + * Auto generated getter method + * @return DSAKeyValueType + */ + public DSAKeyValueType getDSAKeyValue(){ + return localDSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValue + */ + public void setDSAKeyValue(DSAKeyValueType param){ + + clearAllSettingTrackers(); + localDSAKeyValueTracker = param != null; + + this.localDSAKeyValue=param; + + + } + + + /** + * field for RSAKeyValue + */ + + + protected RSAKeyValueType localRSAKeyValue ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localRSAKeyValueTracker = false ; + + public boolean isRSAKeyValueSpecified(){ + return localRSAKeyValueTracker; + } + + + + /** + * Auto generated getter method + * @return RSAKeyValueType + */ + public RSAKeyValueType getRSAKeyValue(){ + return localRSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param RSAKeyValue + */ + public void setRSAKeyValue(RSAKeyValueType param){ + + clearAllSettingTrackers(); + localRSAKeyValueTracker = param != null; + + this.localRSAKeyValue=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyValueType", + xmlWriter); + } + + + } + if (localDSAKeyValueTracker){ + if (localDSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValue cannot be null!!"); + } + localDSAKeyValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DSAKeyValue"), + xmlWriter); + } if (localRSAKeyValueTracker){ + if (localRSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("RSAKeyValue cannot be null!!"); + } + localRSAKeyValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RSAKeyValue"), + xmlWriter); + } if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDSAKeyValueTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValue")); + + + if (localDSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValue cannot be null!!"); + } + elementList.add(localDSAKeyValue); + } if (localRSAKeyValueTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "RSAKeyValue")); + + + if (localRSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("RSAKeyValue cannot be null!!"); + } + elementList.add(localRSAKeyValue); + } if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyValueType object = + new KeyValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"KeyValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (KeyValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DSAKeyValue").equals(reader.getName())){ + + object.setDSAKeyValue(DSAKeyValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RSAKeyValue").equals(reader.getName())){ + + object.setRSAKeyValue(RSAKeyValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname3 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname3); + object.setExtraElement(builder3.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyCMSSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DateTime + */ + + + protected java.util.Calendar localDateTime ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDateTimeTracker = false ; + + public boolean isDateTimeSpecified(){ + return localDateTimeTracker; + } + + + + /** + * Auto generated getter method + * @return java.util.Calendar + */ + public java.util.Calendar getDateTime(){ + return localDateTime; + } + + + + /** + * Auto generated setter method + * @param param DateTime + */ + public void setDateTime(java.util.Calendar param){ + localDateTimeTracker = param != null; + + this.localDateTime=param; + + + } + + + /** + * field for CMSSignature + */ + + + protected javax.activation.DataHandler localCMSSignature ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getCMSSignature(){ + return localCMSSignature; + } + + + + /** + * Auto generated setter method + * @param param CMSSignature + */ + public void setCMSSignature(javax.activation.DataHandler param){ + + this.localCMSSignature=param; + + + } + + + /** + * field for DataObject + */ + + + protected CMSDataObjectOptionalMetaType localDataObject ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDataObjectTracker = false ; + + public boolean isDataObjectSpecified(){ + return localDataObjectTracker; + } + + + + /** + * Auto generated getter method + * @return CMSDataObjectOptionalMetaType + */ + public CMSDataObjectOptionalMetaType getDataObject(){ + return localDataObject; + } + + + + /** + * Auto generated setter method + * @param param DataObject + */ + public void setDataObject(CMSDataObjectOptionalMetaType param){ + localDataObjectTracker = param != null; + + this.localDataObject=param; + + + } + + + /** + * field for TrustProfileID + */ + + + protected org.apache.axis2.databinding.types.Token localTrustProfileID ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getTrustProfileID(){ + return localTrustProfileID; + } + + + + /** + * Auto generated setter method + * @param param TrustProfileID + */ + public void setTrustProfileID(org.apache.axis2.databinding.types.Token param){ + + this.localTrustProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureRequestType", + xmlWriter); + } + + + } + if (localDateTimeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "DateTime", xmlWriter); + + + if (localDateTime==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + + } + + xmlWriter.writeEndElement(); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "CMSSignature", xmlWriter); + + + if (localCMSSignature!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localCMSSignature, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for CMSSignature", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localDataObjectTracker){ + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "TrustProfileID", xmlWriter); + + + if (localTrustProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDateTimeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DateTime")); + + if (localDateTime != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + } else { + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CMSSignature")); + + elementList.add(localCMSSignature); + if (localDataObjectTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TrustProfileID")); + + if (localTrustProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureRequestType object = + new VerifyCMSSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyCMSSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyCMSSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DateTime").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DateTime" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDateTime( + org.apache.axis2.databinding.utils.ConverterUtil.convertToDateTime(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CMSSignature").equals(reader.getName())){ + + object.setCMSSignature(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(CMSDataObjectOptionalMetaType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TrustProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"TrustProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setTrustProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentRequiredRefType extends ContentOptionalRefType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentRequiredRefType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localXMLContentTracker = false; + + localLocRefContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for XMLContent + */ + + + protected XMLContentType localXMLContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLContentTracker = false ; + + public boolean isXMLContentSpecified(){ + return localXMLContentTracker; + } + + + + /** + * Auto generated getter method + * @return XMLContentType + */ + public XMLContentType getXMLContent(){ + return localXMLContent; + } + + + + /** + * Auto generated setter method + * @param param XMLContent + */ + public void setXMLContent(XMLContentType param){ + + clearAllSettingTrackers(); + localXMLContentTracker = param != null; + + this.localXMLContent=param; + + + } + + + /** + * field for LocRefContent + */ + + + protected org.apache.axis2.databinding.types.URI localLocRefContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localLocRefContentTracker = false ; + + public boolean isLocRefContentSpecified(){ + return localLocRefContentTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getLocRefContent(){ + return localLocRefContent; + } + + + + /** + * Auto generated setter method + * @param param LocRefContent + */ + public void setLocRefContent(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localLocRefContentTracker = param != null; + + this.localLocRefContent=param; + + + } + + + /** + * field for Reference + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localReference ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localReferenceTracker = false ; + + public boolean isReferenceSpecified(){ + return localReferenceTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getReference(){ + return localReference; + } + + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localReferenceTracker = param != null; + + this.localReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentRequiredRefType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentRequiredRefType", + xmlWriter); + } + + + } + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localReference is null"); + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localXMLContentTracker){ + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + } if (localLocRefContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localXMLContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + } if (localLocRefContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentRequiredRefType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentRequiredRefType object = + new ContentRequiredRefType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentRequiredRefType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentRequiredRefType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Reference is missing"); + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureInfo_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateSignatureEnvironment + */ + + + protected ContentOptionalRefType localCreateSignatureEnvironment ; + + + /** + * Auto generated getter method + * @return ContentOptionalRefType + */ + public ContentOptionalRefType getCreateSignatureEnvironment(){ + return localCreateSignatureEnvironment; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironment + */ + public void setCreateSignatureEnvironment(ContentOptionalRefType param){ + + this.localCreateSignatureEnvironment=param; + + + } + + + /** + * field for CreateSignatureInfoChoice_type0 + */ + + + protected CreateSignatureInfoChoice_type0 localCreateSignatureInfoChoice_type0 ; + + + /** + * Auto generated getter method + * @return CreateSignatureInfoChoice_type0 + */ + public CreateSignatureInfoChoice_type0 getCreateSignatureInfoChoice_type0(){ + return localCreateSignatureInfoChoice_type0; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureInfoChoice_type0 + */ + public void setCreateSignatureInfoChoice_type0(CreateSignatureInfoChoice_type0 param){ + + this.localCreateSignatureInfoChoice_type0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureInfo_type0", + xmlWriter); + } + + + } + + if (localCreateSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironment cannot be null!!"); + } + localCreateSignatureEnvironment.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironment"), + xmlWriter); + + if (localCreateSignatureInfoChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfoChoice_type0 cannot be null!!"); + } + localCreateSignatureInfoChoice_type0.serialize(null,xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironment")); + + + if (localCreateSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironment cannot be null!!"); + } + elementList.add(localCreateSignatureEnvironment); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureInfoChoice_type0")); + + + if (localCreateSignatureInfoChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfoChoice_type0 cannot be null!!"); + } + elementList.add(localCreateSignatureInfoChoice_type0); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureInfo_type0 object = + new CreateSignatureInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateSignatureInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateSignatureInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironment").equals(reader.getName())){ + + object.setCreateSignatureEnvironment(ContentOptionalRefType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + object.setCreateSignatureInfoChoice_type0(CreateSignatureInfoChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509Data + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "X509Data", + "ns1"); + + + + /** + * field for X509Data + */ + + + protected X509DataType localX509Data ; + + + /** + * Auto generated getter method + * @return X509DataType + */ + public X509DataType getX509Data(){ + return localX509Data; + } + + + + /** + * Auto generated setter method + * @param param X509Data + */ + public void setX509Data(X509DataType param){ + + this.localX509Data=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localX509Data==null){ + throw new org.apache.axis2.databinding.ADBException("X509Data cannot be null!"); + } + localX509Data.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localX509Data.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509Data parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509Data object = + new X509Data(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Data").equals(reader.getName())){ + + object.setX509Data(X509DataType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfoTypeChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfoTypeChoice_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localCreateTransformsInfoProfileTracker = false; + + localCreateTransformsInfoProfileIDTracker = false; + + } + + + /** + * field for CreateTransformsInfoProfile + */ + + + protected CreateTransformsInfoProfile_type0 localCreateTransformsInfoProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateTransformsInfoProfileTracker = false ; + + public boolean isCreateTransformsInfoProfileSpecified(){ + return localCreateTransformsInfoProfileTracker; + } + + + + /** + * Auto generated getter method + * @return CreateTransformsInfoProfile_type0 + */ + public CreateTransformsInfoProfile_type0 getCreateTransformsInfoProfile(){ + return localCreateTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfoProfile + */ + public void setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0 param){ + + clearAllSettingTrackers(); + localCreateTransformsInfoProfileTracker = param != null; + + this.localCreateTransformsInfoProfile=param; + + + } + + + /** + * field for CreateTransformsInfoProfileID + */ + + + protected ProfileIdentifierType localCreateTransformsInfoProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateTransformsInfoProfileIDTracker = false ; + + public boolean isCreateTransformsInfoProfileIDSpecified(){ + return localCreateTransformsInfoProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return ProfileIdentifierType + */ + public ProfileIdentifierType getCreateTransformsInfoProfileID(){ + return localCreateTransformsInfoProfileID; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfoProfileID + */ + public void setCreateTransformsInfoProfileID(ProfileIdentifierType param){ + + clearAllSettingTrackers(); + localCreateTransformsInfoProfileIDTracker = param != null; + + this.localCreateTransformsInfoProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfoTypeChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfoTypeChoice_type0", + xmlWriter); + } + + + } + if (localCreateTransformsInfoProfileTracker){ + if (localCreateTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfile cannot be null!!"); + } + localCreateTransformsInfoProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfile"), + xmlWriter); + } if (localCreateTransformsInfoProfileIDTracker){ + if (localCreateTransformsInfoProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfileID cannot be null!!"); + } + localCreateTransformsInfoProfileID.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfileID"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCreateTransformsInfoProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfoProfile")); + + + if (localCreateTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfile cannot be null!!"); + } + elementList.add(localCreateTransformsInfoProfile); + } if (localCreateTransformsInfoProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfoProfileID")); + + + if (localCreateTransformsInfoProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfileID cannot be null!!"); + } + elementList.add(localCreateTransformsInfoProfileID); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfoTypeChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfoTypeChoice_type0 object = + new DataObjectInfoTypeChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfile").equals(reader.getName())){ + + object.setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfileID").equals(reader.getName())){ + + object.setCreateTransformsInfoProfileID(ProfileIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureInfoChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureInfoChoice_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localCreateSignatureEnvironmentProfileTracker = false; + + localCreateSignatureEnvironmentProfileIDTracker = false; + + } + + + /** + * field for CreateSignatureEnvironmentProfile + */ + + + protected CreateSignatureEnvironmentProfile_type0 localCreateSignatureEnvironmentProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateSignatureEnvironmentProfileTracker = false ; + + public boolean isCreateSignatureEnvironmentProfileSpecified(){ + return localCreateSignatureEnvironmentProfileTracker; + } + + + + /** + * Auto generated getter method + * @return CreateSignatureEnvironmentProfile_type0 + */ + public CreateSignatureEnvironmentProfile_type0 getCreateSignatureEnvironmentProfile(){ + return localCreateSignatureEnvironmentProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironmentProfile + */ + public void setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0 param){ + + clearAllSettingTrackers(); + localCreateSignatureEnvironmentProfileTracker = param != null; + + this.localCreateSignatureEnvironmentProfile=param; + + + } + + + /** + * field for CreateSignatureEnvironmentProfileID + */ + + + protected ProfileIdentifierType localCreateSignatureEnvironmentProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateSignatureEnvironmentProfileIDTracker = false ; + + public boolean isCreateSignatureEnvironmentProfileIDSpecified(){ + return localCreateSignatureEnvironmentProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return ProfileIdentifierType + */ + public ProfileIdentifierType getCreateSignatureEnvironmentProfileID(){ + return localCreateSignatureEnvironmentProfileID; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironmentProfileID + */ + public void setCreateSignatureEnvironmentProfileID(ProfileIdentifierType param){ + + clearAllSettingTrackers(); + localCreateSignatureEnvironmentProfileIDTracker = param != null; + + this.localCreateSignatureEnvironmentProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureInfoChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureInfoChoice_type0", + xmlWriter); + } + + + } + if (localCreateSignatureEnvironmentProfileTracker){ + if (localCreateSignatureEnvironmentProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfile cannot be null!!"); + } + localCreateSignatureEnvironmentProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfile"), + xmlWriter); + } if (localCreateSignatureEnvironmentProfileIDTracker){ + if (localCreateSignatureEnvironmentProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfileID cannot be null!!"); + } + localCreateSignatureEnvironmentProfileID.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfileID"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCreateSignatureEnvironmentProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironmentProfile")); + + + if (localCreateSignatureEnvironmentProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfile cannot be null!!"); + } + elementList.add(localCreateSignatureEnvironmentProfile); + } if (localCreateSignatureEnvironmentProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironmentProfileID")); + + + if (localCreateSignatureEnvironmentProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfileID cannot be null!!"); + } + elementList.add(localCreateSignatureEnvironmentProfileID); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureInfoChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureInfoChoice_type0 object = + new CreateSignatureInfoChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfile").equals(reader.getName())){ + + object.setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfileID").equals(reader.getName())){ + + object.setCreateSignatureEnvironmentProfileID(ProfileIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsInfoProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsInfoProfile", + "ns2"); + + + + /** + * field for VerifyTransformsInfoProfile + */ + + + protected VerifyTransformsInfoProfile_type0 localVerifyTransformsInfoProfile ; + + + /** + * Auto generated getter method + * @return VerifyTransformsInfoProfile_type0 + */ + public VerifyTransformsInfoProfile_type0 getVerifyTransformsInfoProfile(){ + return localVerifyTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param VerifyTransformsInfoProfile + */ + public void setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0 param){ + + this.localVerifyTransformsInfoProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfile cannot be null!"); + } + localVerifyTransformsInfoProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyTransformsInfoProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsInfoProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsInfoProfile object = + new VerifyTransformsInfoProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfile").equals(reader.getName())){ + + object.setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CryptoBinary + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "CryptoBinary", + "ns1"); + + + + /** + * field for CryptoBinary + */ + + + protected javax.activation.DataHandler localCryptoBinary ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getCryptoBinary(){ + return localCryptoBinary; + } + + + + /** + * Auto generated setter method + * @param param CryptoBinary + */ + public void setCryptoBinary(javax.activation.DataHandler param){ + + this.localCryptoBinary=param; + + + } + + + public java.lang.String toString(){ + + return localCryptoBinary.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CryptoBinary", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CryptoBinary", + xmlWriter); + } + } + + if (localCryptoBinary==null){ + + throw new org.apache.axis2.databinding.ADBException("CryptoBinary cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCryptoBinary)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCryptoBinary) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static CryptoBinary fromString(java.lang.String value, + java.lang.String namespaceURI){ + CryptoBinary returnValue = new CryptoBinary(); + + returnValue.setCryptoBinary( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(value)); + + + return returnValue; + } + + public static CryptoBinary fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return CryptoBinary.Factory.fromString(content,namespaceUri); + } else { + return CryptoBinary.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CryptoBinary parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CryptoBinary object = + new CryptoBinary(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"CryptoBinary" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCryptoBinary( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifySignatureInfo_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifySignatureInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for VerifySignatureEnvironment + */ + + + protected ContentOptionalRefType localVerifySignatureEnvironment ; + + + /** + * Auto generated getter method + * @return ContentOptionalRefType + */ + public ContentOptionalRefType getVerifySignatureEnvironment(){ + return localVerifySignatureEnvironment; + } + + + + /** + * Auto generated setter method + * @param param VerifySignatureEnvironment + */ + public void setVerifySignatureEnvironment(ContentOptionalRefType param){ + + this.localVerifySignatureEnvironment=param; + + + } + + + /** + * field for VerifySignatureLocation + */ + + + protected org.apache.axis2.databinding.types.Token localVerifySignatureLocation ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getVerifySignatureLocation(){ + return localVerifySignatureLocation; + } + + + + /** + * Auto generated setter method + * @param param VerifySignatureLocation + */ + public void setVerifySignatureLocation(org.apache.axis2.databinding.types.Token param){ + + this.localVerifySignatureLocation=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifySignatureInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifySignatureInfo_type0", + xmlWriter); + } + + + } + + if (localVerifySignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureEnvironment cannot be null!!"); + } + localVerifySignatureEnvironment.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureEnvironment"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "VerifySignatureLocation", xmlWriter); + + + if (localVerifySignatureLocation==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("VerifySignatureLocation cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localVerifySignatureLocation)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifySignatureEnvironment")); + + + if (localVerifySignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureEnvironment cannot be null!!"); + } + elementList.add(localVerifySignatureEnvironment); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifySignatureLocation")); + + if (localVerifySignatureLocation != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localVerifySignatureLocation)); + } else { + throw new org.apache.axis2.databinding.ADBException("VerifySignatureLocation cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifySignatureInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifySignatureInfo_type0 object = + new VerifySignatureInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifySignatureInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifySignatureInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureEnvironment").equals(reader.getName())){ + + object.setVerifySignatureEnvironment(ContentOptionalRefType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureLocation").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"VerifySignatureLocation" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setVerifySignatureLocation( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SPKIDataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SPKIDataType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SPKIDataTypeSequence + * This was an Array! + */ + + + protected SPKIDataTypeSequence[] localSPKIDataTypeSequence ; + + + /** + * Auto generated getter method + * @return SPKIDataTypeSequence[] + */ + public SPKIDataTypeSequence[] getSPKIDataTypeSequence(){ + return localSPKIDataTypeSequence; + } + + + + + + + /** + * validate the array for SPKIDataTypeSequence + */ + protected void validateSPKIDataTypeSequence(SPKIDataTypeSequence[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SPKIDataTypeSequence + */ + public void setSPKIDataTypeSequence(SPKIDataTypeSequence[] param){ + + validateSPKIDataTypeSequence(param); + + + this.localSPKIDataTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SPKIDataTypeSequence + */ + public void addSPKIDataTypeSequence(SPKIDataTypeSequence param){ + if (localSPKIDataTypeSequence == null){ + localSPKIDataTypeSequence = new SPKIDataTypeSequence[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSPKIDataTypeSequence); + list.add(param); + this.localSPKIDataTypeSequence = + (SPKIDataTypeSequence[])list.toArray( + new SPKIDataTypeSequence[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SPKIDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SPKIDataType", + xmlWriter); + } + + + } + + + if (localSPKIDataTypeSequence!=null){ + for (int i = 0;i < localSPKIDataTypeSequence.length;i++){ + if (localSPKIDataTypeSequence[i] != null){ + localSPKIDataTypeSequence[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localSPKIDataTypeSequence!=null) { + for (int i = 0;i < localSPKIDataTypeSequence.length;i++){ + + if (localSPKIDataTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SPKIDataTypeSequence")); + elementList.add(localSPKIDataTypeSequence[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SPKIDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SPKIDataType object = + new SPKIDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SPKIDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SPKIDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(SPKIDataTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(SPKIDataTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setSPKIDataTypeSequence((SPKIDataTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SPKIDataTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformTypeChoice + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localExtraElementTracker = false; + + localXPathTracker = false; + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + /** + * field for XPath + */ + + + protected java.lang.String localXPath ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXPathTracker = false ; + + public boolean isXPathSpecified(){ + return localXPathTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getXPath(){ + return localXPath; + } + + + + /** + * Auto generated setter method + * @param param XPath + */ + public void setXPath(java.lang.String param){ + + clearAllSettingTrackers(); + localXPathTracker = param != null; + + this.localXPath=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformTypeChoice", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localXPathTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "XPath", xmlWriter); + + + if (localXPath==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("XPath cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localXPath); + + } + + xmlWriter.writeEndElement(); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localXPathTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "XPath")); + + if (localXPath != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localXPath)); + } else { + throw new org.apache.axis2.databinding.ADBException("XPath cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformTypeChoice object = + new TransformTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","XPath").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"XPath" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setXPath( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CanonicalizationMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CanonicalizationMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CanonicalizationMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CanonicalizationMethodType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CanonicalizationMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CanonicalizationMethodType object = + new CanonicalizationMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CanonicalizationMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CanonicalizationMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureRequest extends CreateXMLSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateXMLSignatureRequest", + "ns2"); + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureRequest", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureRequest", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateXMLSignatureRequest")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureRequest object = + new CreateXMLSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateXMLSignatureRequest".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateXMLSignatureRequest)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type0.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureEnvironmentProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironmentProfile", + "ns2"); + + + + /** + * field for CreateSignatureEnvironmentProfile + */ + + + protected CreateSignatureEnvironmentProfile_type0 localCreateSignatureEnvironmentProfile ; + + + /** + * Auto generated getter method + * @return CreateSignatureEnvironmentProfile_type0 + */ + public CreateSignatureEnvironmentProfile_type0 getCreateSignatureEnvironmentProfile(){ + return localCreateSignatureEnvironmentProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironmentProfile + */ + public void setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0 param){ + + this.localCreateSignatureEnvironmentProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateSignatureEnvironmentProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfile cannot be null!"); + } + localCreateSignatureEnvironmentProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateSignatureEnvironmentProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureEnvironmentProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureEnvironmentProfile object = + new CreateSignatureEnvironmentProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfile").equals(reader.getName())){ + + object.setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class MimeTypeType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "MimeTypeType", + "ns2"); + + + + /** + * field for MimeTypeType + */ + + + protected org.apache.axis2.databinding.types.Token localMimeTypeType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getMimeTypeType(){ + return localMimeTypeType; + } + + + + /** + * Auto generated setter method + * @param param MimeTypeType + */ + public void setMimeTypeType(org.apache.axis2.databinding.types.Token param){ + + this.localMimeTypeType=param; + + + } + + + public java.lang.String toString(){ + + return localMimeTypeType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":MimeTypeType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "MimeTypeType", + xmlWriter); + } + } + + if (localMimeTypeType==null){ + + throw new org.apache.axis2.databinding.ADBException("MimeTypeType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeTypeType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeTypeType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static MimeTypeType fromString(java.lang.String value, + java.lang.String namespaceURI){ + MimeTypeType returnValue = new MimeTypeType(); + + returnValue.setMimeTypeType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + return returnValue; + } + + public static MimeTypeType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return MimeTypeType.Factory.fromString(content,namespaceUri); + } else { + return MimeTypeType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static MimeTypeType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + MimeTypeType object = + new MimeTypeType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"MimeTypeType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setMimeTypeType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSDataObjectOptionalMetaType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSDataObjectOptionalMetaType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MetaInfo + */ + + + protected MetaInfoType localMetaInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localMetaInfoTracker = false ; + + public boolean isMetaInfoSpecified(){ + return localMetaInfoTracker; + } + + + + /** + * Auto generated getter method + * @return MetaInfoType + */ + public MetaInfoType getMetaInfo(){ + return localMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param MetaInfo + */ + public void setMetaInfo(MetaInfoType param){ + localMetaInfoTracker = param != null; + + this.localMetaInfo=param; + + + } + + + /** + * field for Content + */ + + + protected CMSContentBaseType localContent ; + + + /** + * Auto generated getter method + * @return CMSContentBaseType + */ + public CMSContentBaseType getContent(){ + return localContent; + } + + + + /** + * Auto generated setter method + * @param param Content + */ + public void setContent(CMSContentBaseType param){ + + this.localContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSDataObjectOptionalMetaType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSDataObjectOptionalMetaType", + xmlWriter); + } + + + } + if (localMetaInfoTracker){ + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + } + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localMetaInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSDataObjectOptionalMetaType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSDataObjectOptionalMetaType object = + new CMSDataObjectOptionalMetaType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSDataObjectOptionalMetaType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSDataObjectOptionalMetaType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(CMSContentBaseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509DataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509DataType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for X509DataTypeSequence + * This was an Array! + */ + + + protected X509DataTypeSequence[] localX509DataTypeSequence ; + + + /** + * Auto generated getter method + * @return X509DataTypeSequence[] + */ + public X509DataTypeSequence[] getX509DataTypeSequence(){ + return localX509DataTypeSequence; + } + + + + + + + /** + * validate the array for X509DataTypeSequence + */ + protected void validateX509DataTypeSequence(X509DataTypeSequence[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param X509DataTypeSequence + */ + public void setX509DataTypeSequence(X509DataTypeSequence[] param){ + + validateX509DataTypeSequence(param); + + + this.localX509DataTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param X509DataTypeSequence + */ + public void addX509DataTypeSequence(X509DataTypeSequence param){ + if (localX509DataTypeSequence == null){ + localX509DataTypeSequence = new X509DataTypeSequence[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localX509DataTypeSequence); + list.add(param); + this.localX509DataTypeSequence = + (X509DataTypeSequence[])list.toArray( + new X509DataTypeSequence[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509DataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509DataType", + xmlWriter); + } + + + } + + + if (localX509DataTypeSequence!=null){ + for (int i = 0;i < localX509DataTypeSequence.length;i++){ + if (localX509DataTypeSequence[i] != null){ + localX509DataTypeSequence[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localX509DataTypeSequence!=null) { + for (int i = 0;i < localX509DataTypeSequence.length;i++){ + + if (localX509DataTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509DataTypeSequence")); + elementList.add(localX509DataTypeSequence[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509DataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509DataType object = + new X509DataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"X509DataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (X509DataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(X509DataTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(X509DataTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setX509DataTypeSequence((X509DataTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + X509DataTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureProperties + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureProperties", + "ns1"); + + + + /** + * field for SignatureProperties + */ + + + protected SignaturePropertiesType localSignatureProperties ; + + + /** + * Auto generated getter method + * @return SignaturePropertiesType + */ + public SignaturePropertiesType getSignatureProperties(){ + return localSignatureProperties; + } + + + + /** + * Auto generated setter method + * @param param SignatureProperties + */ + public void setSignatureProperties(SignaturePropertiesType param){ + + this.localSignatureProperties=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureProperties==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureProperties cannot be null!"); + } + localSignatureProperties.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureProperties.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureProperties parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureProperties object = + new SignatureProperties(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperties").equals(reader.getName())){ + + object.setSignatureProperties(SignaturePropertiesType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyName + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "KeyName", + "ns1"); + + + + /** + * field for KeyName + */ + + + protected java.lang.String localKeyName ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getKeyName(){ + return localKeyName; + } + + + + /** + * Auto generated setter method + * @param param KeyName + */ + public void setKeyName(java.lang.String param){ + + this.localKeyName=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = "http://www.w3.org/2000/09/xmldsig#"; + java.lang.String _localName = "KeyName"; + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyName", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyName", + xmlWriter); + } + } + + if (localKeyName==null){ + + throw new org.apache.axis2.databinding.ADBException("KeyName cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localKeyName); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localKeyName) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyName parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyName object = + new KeyName(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"KeyName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setKeyName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateCMSSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for KeyIdentifier + */ + + + protected KeyIdentifierType localKeyIdentifier ; + + + /** + * Auto generated getter method + * @return KeyIdentifierType + */ + public KeyIdentifierType getKeyIdentifier(){ + return localKeyIdentifier; + } + + + + /** + * Auto generated setter method + * @param param KeyIdentifier + */ + public void setKeyIdentifier(KeyIdentifierType param){ + + this.localKeyIdentifier=param; + + + } + + + /** + * field for SingleSignatureInfo + * This was an Array! + */ + + + protected SingleSignatureInfo_type1[] localSingleSignatureInfo ; + + + /** + * Auto generated getter method + * @return SingleSignatureInfo_type1[] + */ + public SingleSignatureInfo_type1[] getSingleSignatureInfo(){ + return localSingleSignatureInfo; + } + + + + + + + /** + * validate the array for SingleSignatureInfo + */ + protected void validateSingleSignatureInfo(SingleSignatureInfo_type1[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SingleSignatureInfo + */ + public void setSingleSignatureInfo(SingleSignatureInfo_type1[] param){ + + validateSingleSignatureInfo(param); + + + this.localSingleSignatureInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SingleSignatureInfo_type1 + */ + public void addSingleSignatureInfo(SingleSignatureInfo_type1 param){ + if (localSingleSignatureInfo == null){ + localSingleSignatureInfo = new SingleSignatureInfo_type1[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSingleSignatureInfo); + list.add(param); + this.localSingleSignatureInfo = + (SingleSignatureInfo_type1[])list.toArray( + new SingleSignatureInfo_type1[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureRequestType", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureRequestType object = + new CreateCMSSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateCMSSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateCMSSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type1[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type1.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateXMLSignatureResponse", + "ns2"); + + + + /** + * field for CreateXMLSignatureResponse + */ + + + protected CreateXMLSignatureResponseType localCreateXMLSignatureResponse ; + + + /** + * Auto generated getter method + * @return CreateXMLSignatureResponseType + */ + public CreateXMLSignatureResponseType getCreateXMLSignatureResponse(){ + return localCreateXMLSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param CreateXMLSignatureResponse + */ + public void setCreateXMLSignatureResponse(CreateXMLSignatureResponseType param){ + + this.localCreateXMLSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateXMLSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponse cannot be null!"); + } + localCreateXMLSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateXMLSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureResponse object = + new CreateXMLSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateXMLSignatureResponse").equals(reader.getName())){ + + object.setCreateXMLSignatureResponse(CreateXMLSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class IssuingCountry + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "IssuingCountry", + "ns2"); + + + + /** + * field for IssuingCountry + */ + + + protected org.apache.axis2.databinding.types.Token localIssuingCountry ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getIssuingCountry(){ + return localIssuingCountry; + } + + + + /** + * Auto generated setter method + * @param param IssuingCountry + */ + public void setIssuingCountry(org.apache.axis2.databinding.types.Token param){ + + this.localIssuingCountry=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + java.lang.String _localName = "IssuingCountry"; + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":IssuingCountry", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "IssuingCountry", + xmlWriter); + } + } + + if (localIssuingCountry==null){ + + throw new org.apache.axis2.databinding.ADBException("IssuingCountry cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIssuingCountry)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIssuingCountry) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static IssuingCountry parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + IssuingCountry object = + new IssuingCountry(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","IssuingCountry").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"IssuingCountry" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setIssuingCountry( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Hash_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = Hash_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DigestMethod + */ + + + protected DigestMethodType localDigestMethod ; + + + /** + * Auto generated getter method + * @return DigestMethodType + */ + public DigestMethodType getDigestMethod(){ + return localDigestMethod; + } + + + + /** + * Auto generated setter method + * @param param DigestMethod + */ + public void setDigestMethod(DigestMethodType param){ + + this.localDigestMethod=param; + + + } + + + /** + * field for DigestValue + */ + + + protected DigestValueType localDigestValue ; + + + /** + * Auto generated getter method + * @return DigestValueType + */ + public DigestValueType getDigestValue(){ + return localDigestValue; + } + + + + /** + * Auto generated setter method + * @param param DigestValue + */ + public void setDigestValue(DigestValueType param){ + + this.localDigestValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":Hash_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "Hash_type0", + xmlWriter); + } + + + } + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + localDigestMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod"), + xmlWriter); + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + localDigestValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestMethod")); + + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + elementList.add(localDigestMethod); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestValue")); + + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + elementList.add(localDigestValue); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Hash_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Hash_type0 object = + new Hash_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"Hash_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (Hash_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod").equals(reader.getName())){ + + object.setDigestMethod(DigestMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue").equals(reader.getName())){ + + object.setDigestValue(DigestValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PublicAuthorityType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PublicAuthorityType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected java.lang.String localCode ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCodeTracker = false ; + + public boolean isCodeSpecified(){ + return localCodeTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(java.lang.String param){ + localCodeTracker = param != null; + + this.localCode=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PublicAuthorityType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PublicAuthorityType", + xmlWriter); + } + + + } + if (localCodeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localCode); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCodeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PublicAuthorityType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PublicAuthorityType object = + new PublicAuthorityType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"PublicAuthorityType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (PublicAuthorityType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateTransformsInfoProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfoProfile", + "ns2"); + + + + /** + * field for CreateTransformsInfoProfile + */ + + + protected CreateTransformsInfoProfile_type0 localCreateTransformsInfoProfile ; + + + /** + * Auto generated getter method + * @return CreateTransformsInfoProfile_type0 + */ + public CreateTransformsInfoProfile_type0 getCreateTransformsInfoProfile(){ + return localCreateTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfoProfile + */ + public void setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0 param){ + + this.localCreateTransformsInfoProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfile cannot be null!"); + } + localCreateTransformsInfoProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateTransformsInfoProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateTransformsInfoProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateTransformsInfoProfile object = + new CreateTransformsInfoProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfile").equals(reader.getName())){ + + object.setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyCMSSignatureResponse", + "ns2"); + + + + /** + * field for VerifyCMSSignatureResponse + */ + + + protected VerifyCMSSignatureResponseType localVerifyCMSSignatureResponse ; + + + /** + * Auto generated getter method + * @return VerifyCMSSignatureResponseType + */ + public VerifyCMSSignatureResponseType getVerifyCMSSignatureResponse(){ + return localVerifyCMSSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param VerifyCMSSignatureResponse + */ + public void setVerifyCMSSignatureResponse(VerifyCMSSignatureResponseType param){ + + this.localVerifyCMSSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyCMSSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponse cannot be null!"); + } + localVerifyCMSSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyCMSSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureResponse object = + new VerifyCMSSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyCMSSignatureResponse").equals(reader.getName())){ + + object.setVerifyCMSSignatureResponse(VerifyCMSSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateCMSSignatureResponse", + "ns2"); + + + + /** + * field for CreateCMSSignatureResponse + */ + + + protected CreateCMSSignatureResponseType localCreateCMSSignatureResponse ; + + + /** + * Auto generated getter method + * @return CreateCMSSignatureResponseType + */ + public CreateCMSSignatureResponseType getCreateCMSSignatureResponse(){ + return localCreateCMSSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param CreateCMSSignatureResponse + */ + public void setCreateCMSSignatureResponse(CreateCMSSignatureResponseType param){ + + this.localCreateCMSSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateCMSSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponse cannot be null!"); + } + localCreateCMSSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateCMSSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureResponse object = + new CreateCMSSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateCMSSignatureResponse").equals(reader.getName())){ + + object.setCreateCMSSignatureResponse(CreateCMSSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SupplementProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "SupplementProfile", + "ns2"); + + + + /** + * field for SupplementProfile + */ + + + protected XMLDataObjectAssociationType localSupplementProfile ; + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType + */ + public XMLDataObjectAssociationType getSupplementProfile(){ + return localSupplementProfile; + } + + + + /** + * Auto generated setter method + * @param param SupplementProfile + */ + public void setSupplementProfile(XMLDataObjectAssociationType param){ + + this.localSupplementProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSupplementProfile==null){ + throw new org.apache.axis2.databinding.ADBException("SupplementProfile cannot be null!"); + } + localSupplementProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSupplementProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SupplementProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SupplementProfile object = + new SupplementProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfile").equals(reader.getName())){ + + object.setSupplementProfile(XMLDataObjectAssociationType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureResponseTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyCMSSignatureResponseTypeSequence + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for SignerInfo + */ + + + protected KeyInfoType localSignerInfo ; + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getSignerInfo(){ + return localSignerInfo; + } + + + + /** + * Auto generated setter method + * @param param SignerInfo + */ + public void setSignerInfo(KeyInfoType param){ + + this.localSignerInfo=param; + + + } + + + /** + * field for SignatureCheck + */ + + + protected CheckResultType localSignatureCheck ; + + + /** + * Auto generated getter method + * @return CheckResultType + */ + public CheckResultType getSignatureCheck(){ + return localSignatureCheck; + } + + + + /** + * Auto generated setter method + * @param param SignatureCheck + */ + public void setSignatureCheck(CheckResultType param){ + + this.localSignatureCheck=param; + + + } + + + /** + * field for CertificateCheck + */ + + + protected CheckResultType localCertificateCheck ; + + + /** + * Auto generated getter method + * @return CheckResultType + */ + public CheckResultType getCertificateCheck(){ + return localCertificateCheck; + } + + + + /** + * Auto generated setter method + * @param param CertificateCheck + */ + public void setCertificateCheck(CheckResultType param){ + + this.localCertificateCheck=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureResponseTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureResponseTypeSequence", + xmlWriter); + } + + + } + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + localSignerInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo"), + xmlWriter); + + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + localSignatureCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck"), + xmlWriter); + + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + localCertificateCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck"), + xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignerInfo")); + + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + elementList.add(localSignerInfo); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureCheck")); + + + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + elementList.add(localSignatureCheck); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CertificateCheck")); + + + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + elementList.add(localCertificateCheck); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureResponseTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureResponseTypeSequence object = + new VerifyCMSSignatureResponseTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo").equals(reader.getName())){ + + object.setSignerInfo(KeyInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck").equals(reader.getName())){ + + object.setSignatureCheck(CheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck").equals(reader.getName())){ + + object.setCertificateCheck(CheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RetrievalMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "RetrievalMethod", + "ns1"); + + + + /** + * field for RetrievalMethod + */ + + + protected RetrievalMethodType localRetrievalMethod ; + + + /** + * Auto generated getter method + * @return RetrievalMethodType + */ + public RetrievalMethodType getRetrievalMethod(){ + return localRetrievalMethod; + } + + + + /** + * Auto generated setter method + * @param param RetrievalMethod + */ + public void setRetrievalMethod(RetrievalMethodType param){ + + this.localRetrievalMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localRetrievalMethod==null){ + throw new org.apache.axis2.databinding.ADBException("RetrievalMethod cannot be null!"); + } + localRetrievalMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localRetrievalMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RetrievalMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RetrievalMethod object = + new RetrievalMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RetrievalMethod").equals(reader.getName())){ + + object.setRetrievalMethod(RetrievalMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureRequest extends CreateCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateCMSSignatureRequest", + "ns2"); + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureRequest", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureRequest", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateCMSSignatureRequest")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureRequest object = + new CreateCMSSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateCMSSignatureRequest".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateCMSSignatureRequest)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type1[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type1.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyCMSSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for VerifyCMSSignatureResponseTypeSequence + * This was an Array! + */ + + + protected VerifyCMSSignatureResponseTypeSequence[] localVerifyCMSSignatureResponseTypeSequence ; + + + /** + * Auto generated getter method + * @return VerifyCMSSignatureResponseTypeSequence[] + */ + public VerifyCMSSignatureResponseTypeSequence[] getVerifyCMSSignatureResponseTypeSequence(){ + return localVerifyCMSSignatureResponseTypeSequence; + } + + + + + + + /** + * validate the array for VerifyCMSSignatureResponseTypeSequence + */ + protected void validateVerifyCMSSignatureResponseTypeSequence(VerifyCMSSignatureResponseTypeSequence[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param VerifyCMSSignatureResponseTypeSequence + */ + public void setVerifyCMSSignatureResponseTypeSequence(VerifyCMSSignatureResponseTypeSequence[] param){ + + validateVerifyCMSSignatureResponseTypeSequence(param); + + + this.localVerifyCMSSignatureResponseTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyCMSSignatureResponseTypeSequence + */ + public void addVerifyCMSSignatureResponseTypeSequence(VerifyCMSSignatureResponseTypeSequence param){ + if (localVerifyCMSSignatureResponseTypeSequence == null){ + localVerifyCMSSignatureResponseTypeSequence = new VerifyCMSSignatureResponseTypeSequence[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localVerifyCMSSignatureResponseTypeSequence); + list.add(param); + this.localVerifyCMSSignatureResponseTypeSequence = + (VerifyCMSSignatureResponseTypeSequence[])list.toArray( + new VerifyCMSSignatureResponseTypeSequence[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureResponseType", + xmlWriter); + } + + + } + + + if (localVerifyCMSSignatureResponseTypeSequence!=null){ + for (int i = 0;i < localVerifyCMSSignatureResponseTypeSequence.length;i++){ + if (localVerifyCMSSignatureResponseTypeSequence[i] != null){ + localVerifyCMSSignatureResponseTypeSequence[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localVerifyCMSSignatureResponseTypeSequence!=null) { + for (int i = 0;i < localVerifyCMSSignatureResponseTypeSequence.length;i++){ + + if (localVerifyCMSSignatureResponseTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyCMSSignatureResponseTypeSequence")); + elementList.add(localVerifyCMSSignatureResponseTypeSequence[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureResponseType object = + new VerifyCMSSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyCMSSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyCMSSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(VerifyCMSSignatureResponseTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(VerifyCMSSignatureResponseTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setVerifyCMSSignatureResponseTypeSequence((VerifyCMSSignatureResponseTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyCMSSignatureResponseTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ReferencesCheckResultType extends CheckResultType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ReferencesCheckResultType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localCode ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localCode=param; + + + } + + + /** + * field for Info0 + * Type of this field is a subtype of its original. + */ + + + protected ReferencesCheckResultInfoType localInfo0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localInfo0Tracker = false ; + + public boolean isInfo0Specified(){ + return localInfo0Tracker; + } + + + + /** + * Auto generated getter method + * @return ReferencesCheckResultInfoType + */ + public ReferencesCheckResultInfoType getInfo0(){ + return localInfo0; + } + + + + /** + * Auto generated setter method + * @param param Info0 + */ + public void setInfo0(ReferencesCheckResultInfoType param){ + localInfo0Tracker = param != null; + + this.localInfo0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ReferencesCheckResultType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ReferencesCheckResultType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + + } + + xmlWriter.writeEndElement(); + if (localInfo0Tracker){ + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + localInfo0.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + if (localInfo0Tracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info0")); + + + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + elementList.add(localInfo0); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ReferencesCheckResultType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ReferencesCheckResultType object = + new ReferencesCheckResultType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ReferencesCheckResultType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ReferencesCheckResultType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0").equals(reader.getName())){ + + object.setInfo0(ReferencesCheckResultInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ExtensionMapper{ + + public static java.lang.Object getTypeObject(java.lang.String namespaceURI, + java.lang.String typeName, + javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentOptionalRefType".equals(typeName)){ + + return ContentOptionalRefType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyXMLSignatureResponseType".equals(typeName)){ + + return VerifyXMLSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyTransformsInfoProfile_type0".equals(typeName)){ + + return VerifyTransformsInfoProfile_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSDataObjectInfoType".equals(typeName)){ + + return CMSDataObjectInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "PartOf_type0".equals(typeName)){ + + return PartOf_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ManifestRefsCheckResultInfoType".equals(typeName)){ + + return ManifestRefsCheckResultInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "AnyChildrenType".equals(typeName)){ + + return AnyChildrenType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "XMLContentType".equals(typeName)){ + + return XMLContentType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObjectInfoType".equals(typeName)){ + + return DataObjectInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateCMSSignatureResponseType".equals(typeName)){ + + return CreateCMSSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "PGPDataType".equals(typeName)){ + + return PGPDataType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignatureType".equals(typeName)){ + + return SignatureType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "FinalDataMetaInfoType".equals(typeName)){ + + return FinalDataMetaInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentBaseType".equals(typeName)){ + + return ContentBaseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSDataObjectRequiredMetaType".equals(typeName)){ + + return CMSDataObjectRequiredMetaType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ReferencesCheckResultInfoType".equals(typeName)){ + + return ReferencesCheckResultInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObject_type1".equals(typeName)){ + + return DataObject_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObject_type0".equals(typeName)){ + + return DataObject_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "source_type1".equals(typeName)){ + + return Source_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSContentBaseType".equals(typeName)){ + + return CMSContentBaseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "source_type0".equals(typeName)){ + + return Source_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignaturePropertiesType".equals(typeName)){ + + return SignaturePropertiesType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SignatoriesType".equals(typeName)){ + + return SignatoriesType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "X509IssuerSerialType".equals(typeName)){ + + return X509IssuerSerialType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "DSAKeyValueType".equals(typeName)){ + + return DSAKeyValueType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "KeyValueType".equals(typeName)){ + + return KeyValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyCMSSignatureRequestType".equals(typeName)){ + + return VerifyCMSSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentRequiredRefType".equals(typeName)){ + + return ContentRequiredRefType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateSignatureInfo_type0".equals(typeName)){ + + return CreateSignatureInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "CryptoBinary".equals(typeName)){ + + return CryptoBinary.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SPKIDataType".equals(typeName)){ + + return SPKIDataType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifySignatureInfo_type0".equals(typeName)){ + + return VerifySignatureInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "CanonicalizationMethodType".equals(typeName)){ + + return CanonicalizationMethodType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "MimeTypeType".equals(typeName)){ + + return MimeTypeType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSDataObjectOptionalMetaType".equals(typeName)){ + + return CMSDataObjectOptionalMetaType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "X509DataType".equals(typeName)){ + + return X509DataType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateCMSSignatureRequestType".equals(typeName)){ + + return CreateCMSSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "Hash_type0".equals(typeName)){ + + return Hash_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "PublicAuthorityType".equals(typeName)){ + + return PublicAuthorityType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyCMSSignatureResponseType".equals(typeName)){ + + return VerifyCMSSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ReferencesCheckResultType".equals(typeName)){ + + return ReferencesCheckResultType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SignatureManifestCheckParams_type0".equals(typeName)){ + + return SignatureManifestCheckParams_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "MetaInfoType".equals(typeName)){ + + return MetaInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SingleSignatureInfo_type0".equals(typeName)){ + + return SingleSignatureInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "RSAKeyValueType".equals(typeName)){ + + return RSAKeyValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SingleSignatureInfo_type1".equals(typeName)){ + + return SingleSignatureInfo_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "XMLDataObjectAssociationType".equals(typeName)){ + + return XMLDataObjectAssociationType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "KeyIdentifierType".equals(typeName)){ + + return KeyIdentifierType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignedInfoType".equals(typeName)){ + + return SignedInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ErrorResponseType".equals(typeName)){ + + return ErrorResponseType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignatureMethodType".equals(typeName)){ + + return SignatureMethodType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignaturePropertyType".equals(typeName)){ + + return SignaturePropertyType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "RetrievalMethodType".equals(typeName)){ + + return RetrievalMethodType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "TransformType".equals(typeName)){ + + return TransformType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateSignatureEnvironmentProfile_type0".equals(typeName)){ + + return CreateSignatureEnvironmentProfile_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "Structure_type1".equals(typeName)){ + + return Structure_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "InputDataType".equals(typeName)){ + + return InputDataType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "Structure_type0".equals(typeName)){ + + return Structure_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SignatureEnvironment_type0".equals(typeName)){ + + return SignatureEnvironment_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "DigestValueType".equals(typeName)){ + + return DigestValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObjectInfo_type1".equals(typeName)){ + + return DataObjectInfo_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObjectInfo_type0".equals(typeName)){ + + return DataObjectInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/XML/1998/namespace".equals(namespaceURI) && + "space_type0".equals(typeName)){ + + return Space_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "ReferenceType".equals(typeName)){ + + return ReferenceType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "KeyInfoType".equals(typeName)){ + + return KeyInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyTransformsDataType".equals(typeName)){ + + return VerifyTransformsDataType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "DigestMethodType".equals(typeName)){ + + return DigestMethodType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "AllSignatoriesType".equals(typeName)){ + + return AllSignatoriesType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "TransformsInfoType".equals(typeName)){ + + return TransformsInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentExLocRefBaseType".equals(typeName)){ + + return ContentExLocRefBaseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateXMLSignatureRequestType".equals(typeName)){ + + return CreateXMLSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignatureValueType".equals(typeName)){ + + return SignatureValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "TransformParameterType".equals(typeName)){ + + return TransformParameterType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "ManifestType".equals(typeName)){ + + return ManifestType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "HMACOutputLengthType".equals(typeName)){ + + return HMACOutputLengthType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateSignatureLocationType".equals(typeName)){ + + return CreateSignatureLocationType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "TransformsType".equals(typeName)){ + + return TransformsType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateXMLSignatureResponseType".equals(typeName)){ + + return CreateXMLSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateTransformsInfoProfile_type0".equals(typeName)){ + + return CreateTransformsInfoProfile_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyXMLSignatureRequestType".equals(typeName)){ + + return VerifyXMLSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ProfileIdentifierType".equals(typeName)){ + + return ProfileIdentifierType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ManifestRefsCheckResultType".equals(typeName)){ + + return ManifestRefsCheckResultType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CheckResultType".equals(typeName)){ + + return CheckResultType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "ObjectType".equals(typeName)){ + + return ObjectType.Factory.parse(reader); + + + } + + + throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName); + } + + } + + public static class SignatureManifestCheckParams_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureManifestCheckParams_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ReferenceInfo + * This was an Array! + */ + + + protected VerifyTransformsDataType[] localReferenceInfo ; + + + /** + * Auto generated getter method + * @return VerifyTransformsDataType[] + */ + public VerifyTransformsDataType[] getReferenceInfo(){ + return localReferenceInfo; + } + + + + + + + /** + * validate the array for ReferenceInfo + */ + protected void validateReferenceInfo(VerifyTransformsDataType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param ReferenceInfo + */ + public void setReferenceInfo(VerifyTransformsDataType[] param){ + + validateReferenceInfo(param); + + + this.localReferenceInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyTransformsDataType + */ + public void addReferenceInfo(VerifyTransformsDataType param){ + if (localReferenceInfo == null){ + localReferenceInfo = new VerifyTransformsDataType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReferenceInfo); + list.add(param); + this.localReferenceInfo = + (VerifyTransformsDataType[])list.toArray( + new VerifyTransformsDataType[list.size()]); + + } + + + /** + * field for ReturnReferenceInputData + * This was an Attribute! + */ + + + protected boolean localReturnReferenceInputData = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("true"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getReturnReferenceInputData(){ + return localReturnReferenceInputData; + } + + + + /** + * Auto generated setter method + * @param param ReturnReferenceInputData + */ + public void setReturnReferenceInputData(boolean param){ + + this.localReturnReferenceInputData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureManifestCheckParams_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureManifestCheckParams_type0", + xmlWriter); + } + + + } + + if (true) { + + writeAttribute("", + "ReturnReferenceInputData", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReturnReferenceInputData), xmlWriter); + + + } + + if (localReferenceInfo!=null){ + for (int i = 0;i < localReferenceInfo.length;i++){ + if (localReferenceInfo[i] != null){ + localReferenceInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localReferenceInfo!=null) { + for (int i = 0;i < localReferenceInfo.length;i++){ + + if (localReferenceInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReferenceInfo")); + elementList.add(localReferenceInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","ReturnReferenceInputData")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReturnReferenceInputData)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureManifestCheckParams_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureManifestCheckParams_type0 object = + new SignatureManifestCheckParams_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureManifestCheckParams_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureManifestCheckParams_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "ReturnReferenceInputData" + java.lang.String tempAttribReturnReferenceInputData = + + reader.getAttributeValue(null,"ReturnReferenceInputData"); + + if (tempAttribReturnReferenceInputData!=null){ + java.lang.String content = tempAttribReturnReferenceInputData; + + object.setReturnReferenceInputData( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribReturnReferenceInputData)); + + } else { + + } + handledAttributes.add("ReturnReferenceInputData"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(VerifyTransformsDataType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInfo").equals(reader.getName())){ + list1.add(VerifyTransformsDataType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReferenceInfo((VerifyTransformsDataType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyTransformsDataType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class MetaInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = MetaInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MimeType + */ + + + protected MimeTypeType localMimeType ; + + + /** + * Auto generated getter method + * @return MimeTypeType + */ + public MimeTypeType getMimeType(){ + return localMimeType; + } + + + + /** + * Auto generated setter method + * @param param MimeType + */ + public void setMimeType(MimeTypeType param){ + + this.localMimeType=param; + + + } + + + /** + * field for Description + */ + + + protected org.apache.axis2.databinding.types.URI localDescription ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDescriptionTracker = false ; + + public boolean isDescriptionSpecified(){ + return localDescriptionTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getDescription(){ + return localDescription; + } + + + + /** + * Auto generated setter method + * @param param Description + */ + public void setDescription(org.apache.axis2.databinding.types.URI param){ + localDescriptionTracker = param != null; + + this.localDescription=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":MetaInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "MetaInfoType", + xmlWriter); + } + + + } + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + localMimeType.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType"), + xmlWriter); + if (localDescriptionTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Description", xmlWriter); + + + if (localDescription==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MimeType")); + + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + elementList.add(localMimeType); + if (localDescriptionTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Description")); + + if (localDescription != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + } else { + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + } + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static MetaInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + MetaInfoType object = + new MetaInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"MetaInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (MetaInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType").equals(reader.getName())){ + + object.setMimeType(MimeTypeType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Description").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Description" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDescription( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone3=false; + + while (!loopDone3){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list3.add(builder3.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone3 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone3 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list3)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureProperty + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureProperty", + "ns1"); + + + + /** + * field for SignatureProperty + */ + + + protected SignaturePropertyType localSignatureProperty ; + + + /** + * Auto generated getter method + * @return SignaturePropertyType + */ + public SignaturePropertyType getSignatureProperty(){ + return localSignatureProperty; + } + + + + /** + * Auto generated setter method + * @param param SignatureProperty + */ + public void setSignatureProperty(SignaturePropertyType param){ + + this.localSignatureProperty=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureProperty==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!"); + } + localSignatureProperty.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureProperty.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureProperty parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureProperty object = + new SignatureProperty(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty").equals(reader.getName())){ + + object.setSignatureProperty(SignaturePropertyType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SingleSignatureInfo_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SingleSignatureInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObjectInfo + * This was an Array! + */ + + + protected DataObjectInfo_type0[] localDataObjectInfo ; + + + /** + * Auto generated getter method + * @return DataObjectInfo_type0[] + */ + public DataObjectInfo_type0[] getDataObjectInfo(){ + return localDataObjectInfo; + } + + + + + + + /** + * validate the array for DataObjectInfo + */ + protected void validateDataObjectInfo(DataObjectInfo_type0[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param DataObjectInfo + */ + public void setDataObjectInfo(DataObjectInfo_type0[] param){ + + validateDataObjectInfo(param); + + + this.localDataObjectInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param DataObjectInfo_type0 + */ + public void addDataObjectInfo(DataObjectInfo_type0 param){ + if (localDataObjectInfo == null){ + localDataObjectInfo = new DataObjectInfo_type0[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localDataObjectInfo); + list.add(param); + this.localDataObjectInfo = + (DataObjectInfo_type0[])list.toArray( + new DataObjectInfo_type0[list.size()]); + + } + + + /** + * field for CreateSignatureInfo + */ + + + protected CreateSignatureInfo_type0 localCreateSignatureInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateSignatureInfoTracker = false ; + + public boolean isCreateSignatureInfoSpecified(){ + return localCreateSignatureInfoTracker; + } + + + + /** + * Auto generated getter method + * @return CreateSignatureInfo_type0 + */ + public CreateSignatureInfo_type0 getCreateSignatureInfo(){ + return localCreateSignatureInfo; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureInfo + */ + public void setCreateSignatureInfo(CreateSignatureInfo_type0 param){ + localCreateSignatureInfoTracker = param != null; + + this.localCreateSignatureInfo=param; + + + } + + + /** + * field for SecurityLayerConformity + * This was an Attribute! + */ + + + protected boolean localSecurityLayerConformity = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("true"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getSecurityLayerConformity(){ + return localSecurityLayerConformity; + } + + + + /** + * Auto generated setter method + * @param param SecurityLayerConformity + */ + public void setSecurityLayerConformity(boolean param){ + + this.localSecurityLayerConformity=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SingleSignatureInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SingleSignatureInfo_type0", + xmlWriter); + } + + + } + + if (true) { + + writeAttribute("", + "SecurityLayerConformity", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity), xmlWriter); + + + } + + if (localDataObjectInfo!=null){ + for (int i = 0;i < localDataObjectInfo.length;i++){ + if (localDataObjectInfo[i] != null){ + localDataObjectInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + + } + if (localCreateSignatureInfoTracker){ + if (localCreateSignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfo cannot be null!!"); + } + localCreateSignatureInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureInfo"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localDataObjectInfo!=null) { + for (int i = 0;i < localDataObjectInfo.length;i++){ + + if (localDataObjectInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfo")); + elementList.add(localDataObjectInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + + } + + if (localCreateSignatureInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureInfo")); + + + if (localCreateSignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfo cannot be null!!"); + } + elementList.add(localCreateSignatureInfo); + } + attribList.add( + new javax.xml.namespace.QName("","SecurityLayerConformity")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SingleSignatureInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SingleSignatureInfo_type0 object = + new SingleSignatureInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SingleSignatureInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SingleSignatureInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "SecurityLayerConformity" + java.lang.String tempAttribSecurityLayerConformity = + + reader.getAttributeValue(null,"SecurityLayerConformity"); + + if (tempAttribSecurityLayerConformity!=null){ + java.lang.String content = tempAttribSecurityLayerConformity; + + object.setSecurityLayerConformity( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribSecurityLayerConformity)); + + } else { + + } + handledAttributes.add("SecurityLayerConformity"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(DataObjectInfo_type0.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo").equals(reader.getName())){ + list1.add(DataObjectInfo_type0.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setDataObjectInfo((DataObjectInfo_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + DataObjectInfo_type0.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureInfo").equals(reader.getName())){ + + object.setCreateSignatureInfo(CreateSignatureInfo_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RSAKeyValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = RSAKeyValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Modulus + */ + + + protected CryptoBinary localModulus ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getModulus(){ + return localModulus; + } + + + + /** + * Auto generated setter method + * @param param Modulus + */ + public void setModulus(CryptoBinary param){ + + this.localModulus=param; + + + } + + + /** + * field for Exponent + */ + + + protected CryptoBinary localExponent ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getExponent(){ + return localExponent; + } + + + + /** + * Auto generated setter method + * @param param Exponent + */ + public void setExponent(CryptoBinary param){ + + this.localExponent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":RSAKeyValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "RSAKeyValueType", + xmlWriter); + } + + + } + + if (localModulus==null){ + throw new org.apache.axis2.databinding.ADBException("Modulus cannot be null!!"); + } + localModulus.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Modulus"), + xmlWriter); + + if (localExponent==null){ + throw new org.apache.axis2.databinding.ADBException("Exponent cannot be null!!"); + } + localExponent.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Exponent"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Modulus")); + + + if (localModulus==null){ + throw new org.apache.axis2.databinding.ADBException("Modulus cannot be null!!"); + } + elementList.add(localModulus); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Exponent")); + + + if (localExponent==null){ + throw new org.apache.axis2.databinding.ADBException("Exponent cannot be null!!"); + } + elementList.add(localExponent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RSAKeyValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RSAKeyValueType object = + new RSAKeyValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"RSAKeyValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (RSAKeyValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Modulus").equals(reader.getName())){ + + object.setModulus(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Exponent").equals(reader.getName())){ + + object.setExponent(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SingleSignatureInfo_type1 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SingleSignatureInfo_type1 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObjectInfo + */ + + + protected DataObjectInfo_type1 localDataObjectInfo ; + + + /** + * Auto generated getter method + * @return DataObjectInfo_type1 + */ + public DataObjectInfo_type1 getDataObjectInfo(){ + return localDataObjectInfo; + } + + + + /** + * Auto generated setter method + * @param param DataObjectInfo + */ + public void setDataObjectInfo(DataObjectInfo_type1 param){ + + this.localDataObjectInfo=param; + + + } + + + /** + * field for SecurityLayerConformity + * This was an Attribute! + */ + + + protected boolean localSecurityLayerConformity = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("true"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getSecurityLayerConformity(){ + return localSecurityLayerConformity; + } + + + + /** + * Auto generated setter method + * @param param SecurityLayerConformity + */ + public void setSecurityLayerConformity(boolean param){ + + this.localSecurityLayerConformity=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SingleSignatureInfo_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SingleSignatureInfo_type1", + xmlWriter); + } + + + } + + if (true) { + + writeAttribute("", + "SecurityLayerConformity", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity), xmlWriter); + + + } + + if (localDataObjectInfo==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + } + localDataObjectInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfo")); + + + if (localDataObjectInfo==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + } + elementList.add(localDataObjectInfo); + + attribList.add( + new javax.xml.namespace.QName("","SecurityLayerConformity")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SingleSignatureInfo_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SingleSignatureInfo_type1 object = + new SingleSignatureInfo_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SingleSignatureInfo_type1".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SingleSignatureInfo_type1)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "SecurityLayerConformity" + java.lang.String tempAttribSecurityLayerConformity = + + reader.getAttributeValue(null,"SecurityLayerConformity"); + + if (tempAttribSecurityLayerConformity!=null){ + java.lang.String content = tempAttribSecurityLayerConformity; + + object.setSecurityLayerConformity( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribSecurityLayerConformity)); + + } else { + + } + handledAttributes.add("SecurityLayerConformity"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo").equals(reader.getName())){ + + object.setDataObjectInfo(DataObjectInfo_type1.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class XMLDataObjectAssociationType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = XMLDataObjectAssociationType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MetaInfo + */ + + + protected MetaInfoType localMetaInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localMetaInfoTracker = false ; + + public boolean isMetaInfoSpecified(){ + return localMetaInfoTracker; + } + + + + /** + * Auto generated getter method + * @return MetaInfoType + */ + public MetaInfoType getMetaInfo(){ + return localMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param MetaInfo + */ + public void setMetaInfo(MetaInfoType param){ + localMetaInfoTracker = param != null; + + this.localMetaInfo=param; + + + } + + + /** + * field for Content + */ + + + protected ContentRequiredRefType localContent ; + + + /** + * Auto generated getter method + * @return ContentRequiredRefType + */ + public ContentRequiredRefType getContent(){ + return localContent; + } + + + + /** + * Auto generated setter method + * @param param Content + */ + public void setContent(ContentRequiredRefType param){ + + this.localContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":XMLDataObjectAssociationType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "XMLDataObjectAssociationType", + xmlWriter); + } + + + } + if (localMetaInfoTracker){ + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + } + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localMetaInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static XMLDataObjectAssociationType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + XMLDataObjectAssociationType object = + new XMLDataObjectAssociationType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"XMLDataObjectAssociationType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (XMLDataObjectAssociationType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(ContentRequiredRefType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignaturePropertyTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignaturePropertyTypeChoice + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localExtraElementTracker = false; + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignaturePropertyTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignaturePropertyTypeChoice", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignaturePropertyTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignaturePropertyTypeChoice object = + new SignaturePropertyTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignedInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignedInfoType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for CanonicalizationMethod + */ + + + protected CanonicalizationMethodType localCanonicalizationMethod ; + + + /** + * Auto generated getter method + * @return CanonicalizationMethodType + */ + public CanonicalizationMethodType getCanonicalizationMethod(){ + return localCanonicalizationMethod; + } + + + + /** + * Auto generated setter method + * @param param CanonicalizationMethod + */ + public void setCanonicalizationMethod(CanonicalizationMethodType param){ + + this.localCanonicalizationMethod=param; + + + } + + + /** + * field for SignatureMethod + */ + + + protected SignatureMethodType localSignatureMethod ; + + + /** + * Auto generated getter method + * @return SignatureMethodType + */ + public SignatureMethodType getSignatureMethod(){ + return localSignatureMethod; + } + + + + /** + * Auto generated setter method + * @param param SignatureMethod + */ + public void setSignatureMethod(SignatureMethodType param){ + + this.localSignatureMethod=param; + + + } + + + /** + * field for Reference + * This was an Array! + */ + + + protected ReferenceType[] localReference ; + + + /** + * Auto generated getter method + * @return ReferenceType[] + */ + public ReferenceType[] getReference(){ + return localReference; + } + + + + + + + /** + * validate the array for Reference + */ + protected void validateReference(ReferenceType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(ReferenceType[] param){ + + validateReference(param); + + + this.localReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ReferenceType + */ + public void addReference(ReferenceType param){ + if (localReference == null){ + localReference = new ReferenceType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReference); + list.add(param); + this.localReference = + (ReferenceType[])list.toArray( + new ReferenceType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignedInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignedInfoType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localCanonicalizationMethod==null){ + throw new org.apache.axis2.databinding.ADBException("CanonicalizationMethod cannot be null!!"); + } + localCanonicalizationMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","CanonicalizationMethod"), + xmlWriter); + + if (localSignatureMethod==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureMethod cannot be null!!"); + } + localSignatureMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureMethod"), + xmlWriter); + + if (localReference!=null){ + for (int i = 0;i < localReference.length;i++){ + if (localReference[i] != null){ + localReference[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "CanonicalizationMethod")); + + + if (localCanonicalizationMethod==null){ + throw new org.apache.axis2.databinding.ADBException("CanonicalizationMethod cannot be null!!"); + } + elementList.add(localCanonicalizationMethod); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignatureMethod")); + + + if (localSignatureMethod==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureMethod cannot be null!!"); + } + elementList.add(localSignatureMethod); + + if (localReference!=null) { + for (int i = 0;i < localReference.length;i++){ + + if (localReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Reference")); + elementList.add(localReference[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignedInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignedInfoType object = + new SignedInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignedInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignedInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","CanonicalizationMethod").equals(reader.getName())){ + + object.setCanonicalizationMethod(CanonicalizationMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureMethod").equals(reader.getName())){ + + object.setSignatureMethod(SignatureMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list3.add(ReferenceType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone3 = false; + while(!loopDone3){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone3 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + list3.add(ReferenceType.Factory.parse(reader)); + + }else{ + loopDone3 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReference((ReferenceType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ReferenceType.class, + list3)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyIdentifierType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifierType", + "ns2"); + + + + /** + * field for KeyIdentifierType + */ + + + protected java.lang.String localKeyIdentifierType ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getKeyIdentifierType(){ + return localKeyIdentifierType; + } + + + + /** + * Auto generated setter method + * @param param KeyIdentifierType + */ + public void setKeyIdentifierType(java.lang.String param){ + + this.localKeyIdentifierType=param; + + + } + + + public java.lang.String toString(){ + + return localKeyIdentifierType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyIdentifierType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyIdentifierType", + xmlWriter); + } + } + + if (localKeyIdentifierType==null){ + + throw new org.apache.axis2.databinding.ADBException("KeyIdentifierType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localKeyIdentifierType); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localKeyIdentifierType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static KeyIdentifierType fromString(java.lang.String value, + java.lang.String namespaceURI){ + KeyIdentifierType returnValue = new KeyIdentifierType(); + + returnValue.setKeyIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + return returnValue; + } + + public static KeyIdentifierType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return KeyIdentifierType.Factory.fromString(content,namespaceUri); + } else { + return KeyIdentifierType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyIdentifierType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyIdentifierType object = + new KeyIdentifierType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"KeyIdentifierType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setKeyIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SecureSignatureCreationDevice + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "SecureSignatureCreationDevice", + "ns2"); + + + + /** + * field for Source + * This was an Attribute! + */ + + + protected Source_type0 localSource ; + + + /** + * Auto generated getter method + * @return Source_type0 + */ + public Source_type0 getSource(){ + return localSource; + } + + + + /** + * Auto generated setter method + * @param param Source + */ + public void setSource(Source_type0 param){ + + this.localSource=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SecureSignatureCreationDevice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SecureSignatureCreationDevice", + xmlWriter); + } + + + } + + + if (localSource != null){ + writeAttribute("", + "source", + localSource.toString(), xmlWriter); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add( + new javax.xml.namespace.QName("","source")); + + attribList.add(localSource.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SecureSignatureCreationDevice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SecureSignatureCreationDevice object = + new SecureSignatureCreationDevice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SecureSignatureCreationDevice".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SecureSignatureCreationDevice)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "source" + java.lang.String tempAttribSource = + + reader.getAttributeValue(null,"source"); + + if (tempAttribSource!=null){ + java.lang.String content = tempAttribSource; + + object.setSource( + Source_type0.Factory.fromString(reader,tempAttribSource)); + + } else { + + } + handledAttributes.add("source"); + + + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ErrorResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ErrorResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ErrorCode + */ + + + protected java.math.BigInteger localErrorCode ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getErrorCode(){ + return localErrorCode; + } + + + + /** + * Auto generated setter method + * @param param ErrorCode + */ + public void setErrorCode(java.math.BigInteger param){ + + this.localErrorCode=param; + + + } + + + /** + * field for Info + */ + + + protected java.lang.String localInfo ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getInfo(){ + return localInfo; + } + + + + /** + * Auto generated setter method + * @param param Info + */ + public void setInfo(java.lang.String param){ + + this.localInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ErrorResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ErrorResponseType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "ErrorCode", xmlWriter); + + + if (localErrorCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("ErrorCode cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localErrorCode)); + + } + + xmlWriter.writeEndElement(); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Info", xmlWriter); + + + if (localInfo==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localInfo); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorCode")); + + if (localErrorCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localErrorCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("ErrorCode cannot be null!!"); + } + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info")); + + if (localInfo != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localInfo)); + } else { + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ErrorResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ErrorResponseType object = + new ErrorResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ErrorResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ErrorResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorCode").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ErrorCode" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setErrorCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Info" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setInfo( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for HMACOutputLength + */ + + + protected HMACOutputLengthType localHMACOutputLength ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localHMACOutputLengthTracker = false ; + + public boolean isHMACOutputLengthSpecified(){ + return localHMACOutputLengthTracker; + } + + + + /** + * Auto generated getter method + * @return HMACOutputLengthType + */ + public HMACOutputLengthType getHMACOutputLength(){ + return localHMACOutputLength; + } + + + + /** + * Auto generated setter method + * @param param HMACOutputLength + */ + public void setHMACOutputLength(HMACOutputLengthType param){ + localHMACOutputLengthTracker = param != null; + + this.localHMACOutputLength=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureMethodType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localHMACOutputLengthTracker){ + if (localHMACOutputLength==null){ + throw new org.apache.axis2.databinding.ADBException("HMACOutputLength cannot be null!!"); + } + localHMACOutputLength.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","HMACOutputLength"), + xmlWriter); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localHMACOutputLengthTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "HMACOutputLength")); + + + if (localHMACOutputLength==null){ + throw new org.apache.axis2.databinding.ADBException("HMACOutputLength cannot be null!!"); + } + elementList.add(localHMACOutputLength); + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureMethodType object = + new SignatureMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","HMACOutputLength").equals(reader.getName())){ + + object.setHMACOutputLength(HMACOutputLengthType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone2=false; + + while (!loopDone2){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder2 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list2.add(builder2.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone2 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone2 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Reference + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Reference", + "ns1"); + + + + /** + * field for Reference + */ + + + protected ReferenceType localReference ; + + + /** + * Auto generated getter method + * @return ReferenceType + */ + public ReferenceType getReference(){ + return localReference; + } + + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(ReferenceType param){ + + this.localReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localReference==null){ + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!"); + } + localReference.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localReference.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Reference parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Reference object = + new Reference(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + + object.setReference(ReferenceType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for TransformTypeChoice + * This was an Array! + */ + + + protected TransformTypeChoice[] localTransformTypeChoice ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformTypeChoiceTracker = false ; + + public boolean isTransformTypeChoiceSpecified(){ + return localTransformTypeChoiceTracker; + } + + + + /** + * Auto generated getter method + * @return TransformTypeChoice[] + */ + public TransformTypeChoice[] getTransformTypeChoice(){ + return localTransformTypeChoice; + } + + + + + + + /** + * validate the array for TransformTypeChoice + */ + protected void validateTransformTypeChoice(TransformTypeChoice[] param){ + + } + + + /** + * Auto generated setter method + * @param param TransformTypeChoice + */ + public void setTransformTypeChoice(TransformTypeChoice[] param){ + + validateTransformTypeChoice(param); + + localTransformTypeChoiceTracker = param != null; + + this.localTransformTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param TransformTypeChoice + */ + public void addTransformTypeChoice(TransformTypeChoice param){ + if (localTransformTypeChoice == null){ + localTransformTypeChoice = new TransformTypeChoice[]{}; + } + + + //update the setting tracker + localTransformTypeChoiceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localTransformTypeChoice); + list.add(param); + this.localTransformTypeChoice = + (TransformTypeChoice[])list.toArray( + new TransformTypeChoice[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localTransformTypeChoiceTracker){ + + if (localTransformTypeChoice!=null){ + for (int i = 0;i < localTransformTypeChoice.length;i++){ + if (localTransformTypeChoice[i] != null){ + localTransformTypeChoice[i].serialize(null,xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("TransformTypeChoice cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformTypeChoiceTracker){ + if (localTransformTypeChoice!=null) { + for (int i = 0;i < localTransformTypeChoice.length;i++){ + + if (localTransformTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "TransformTypeChoice")); + elementList.add(localTransformTypeChoice[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("TransformTypeChoice cannot be null!!"); + + } + + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformType object = + new TransformType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(TransformTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(TransformTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setTransformTypeChoice((TransformTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + TransformTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RetrievalMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = RetrievalMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for URI + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localURI ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getURI(){ + return localURI; + } + + + + /** + * Auto generated setter method + * @param param URI + */ + public void setURI(org.apache.axis2.databinding.types.URI param){ + + this.localURI=param; + + + } + + + /** + * field for Type + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getType(){ + return localType; + } + + + + /** + * Auto generated setter method + * @param param Type + */ + public void setType(org.apache.axis2.databinding.types.URI param){ + + this.localType=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":RetrievalMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "RetrievalMethodType", + xmlWriter); + } + + + } + + if (localURI != null){ + + writeAttribute("", + "URI", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI), xmlWriter); + + + } + + if (localType != null){ + + writeAttribute("", + "Type", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType), xmlWriter); + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } + attribList.add( + new javax.xml.namespace.QName("","URI")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI)); + + attribList.add( + new javax.xml.namespace.QName("","Type")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RetrievalMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RetrievalMethodType object = + new RetrievalMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"RetrievalMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (RetrievalMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "URI" + java.lang.String tempAttribURI = + + reader.getAttributeValue(null,"URI"); + + if (tempAttribURI!=null){ + java.lang.String content = tempAttribURI; + + object.setURI( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribURI)); + + } else { + + } + handledAttributes.add("URI"); + + // handle attribute "Type" + java.lang.String tempAttribType = + + reader.getAttributeValue(null,"Type"); + + if (tempAttribType!=null){ + java.lang.String content = tempAttribType; + + object.setType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribType)); + + } else { + + } + handledAttributes.add("Type"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignaturePropertyType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignaturePropertyType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SignaturePropertyTypeChoice + * This was an Array! + */ + + + protected SignaturePropertyTypeChoice[] localSignaturePropertyTypeChoice ; + + + /** + * Auto generated getter method + * @return SignaturePropertyTypeChoice[] + */ + public SignaturePropertyTypeChoice[] getSignaturePropertyTypeChoice(){ + return localSignaturePropertyTypeChoice; + } + + + + + + + /** + * validate the array for SignaturePropertyTypeChoice + */ + protected void validateSignaturePropertyTypeChoice(SignaturePropertyTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SignaturePropertyTypeChoice + */ + public void setSignaturePropertyTypeChoice(SignaturePropertyTypeChoice[] param){ + + validateSignaturePropertyTypeChoice(param); + + + this.localSignaturePropertyTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SignaturePropertyTypeChoice + */ + public void addSignaturePropertyTypeChoice(SignaturePropertyTypeChoice param){ + if (localSignaturePropertyTypeChoice == null){ + localSignaturePropertyTypeChoice = new SignaturePropertyTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSignaturePropertyTypeChoice); + list.add(param); + this.localSignaturePropertyTypeChoice = + (SignaturePropertyTypeChoice[])list.toArray( + new SignaturePropertyTypeChoice[list.size()]); + + } + + + /** + * field for Target + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localTarget ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getTarget(){ + return localTarget; + } + + + + /** + * Auto generated setter method + * @param param Target + */ + public void setTarget(org.apache.axis2.databinding.types.URI param){ + + this.localTarget=param; + + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignaturePropertyType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignaturePropertyType", + xmlWriter); + } + + + } + + if (localTarget != null){ + + writeAttribute("", + "Target", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTarget), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localTarget is null"); + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + + if (localSignaturePropertyTypeChoice!=null){ + for (int i = 0;i < localSignaturePropertyTypeChoice.length;i++){ + if (localSignaturePropertyTypeChoice[i] != null){ + localSignaturePropertyTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localSignaturePropertyTypeChoice!=null) { + for (int i = 0;i < localSignaturePropertyTypeChoice.length;i++){ + + if (localSignaturePropertyTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignaturePropertyTypeChoice")); + elementList.add(localSignaturePropertyTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Target")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTarget)); + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignaturePropertyType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignaturePropertyType object = + new SignaturePropertyType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignaturePropertyType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignaturePropertyType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Target" + java.lang.String tempAttribTarget = + + reader.getAttributeValue(null,"Target"); + + if (tempAttribTarget!=null){ + java.lang.String content = tempAttribTarget; + + object.setTarget( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribTarget)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Target is missing"); + + } + handledAttributes.add("Target"); + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(SignaturePropertyTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(SignaturePropertyTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setSignaturePropertyTypeChoice((SignaturePropertyTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SignaturePropertyTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureEnvironmentProfile_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureEnvironmentProfile_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateSignatureLocation + */ + + + protected CreateSignatureLocationType localCreateSignatureLocation ; + + + /** + * Auto generated getter method + * @return CreateSignatureLocationType + */ + public CreateSignatureLocationType getCreateSignatureLocation(){ + return localCreateSignatureLocation; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureLocation + */ + public void setCreateSignatureLocation(CreateSignatureLocationType param){ + + this.localCreateSignatureLocation=param; + + + } + + + /** + * field for Supplement + * This was an Array! + */ + + + protected XMLDataObjectAssociationType[] localSupplement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementTracker = false ; + + public boolean isSupplementSpecified(){ + return localSupplementTracker; + } + + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType[] + */ + public XMLDataObjectAssociationType[] getSupplement(){ + return localSupplement; + } + + + + + + + /** + * validate the array for Supplement + */ + protected void validateSupplement(XMLDataObjectAssociationType[] param){ + + } + + + /** + * Auto generated setter method + * @param param Supplement + */ + public void setSupplement(XMLDataObjectAssociationType[] param){ + + validateSupplement(param); + + localSupplementTracker = param != null; + + this.localSupplement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param XMLDataObjectAssociationType + */ + public void addSupplement(XMLDataObjectAssociationType param){ + if (localSupplement == null){ + localSupplement = new XMLDataObjectAssociationType[]{}; + } + + + //update the setting tracker + localSupplementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSupplement); + list.add(param); + this.localSupplement = + (XMLDataObjectAssociationType[])list.toArray( + new XMLDataObjectAssociationType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureEnvironmentProfile_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureEnvironmentProfile_type0", + xmlWriter); + } + + + } + + if (localCreateSignatureLocation==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureLocation cannot be null!!"); + } + localCreateSignatureLocation.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureLocation"), + xmlWriter); + if (localSupplementTracker){ + if (localSupplement!=null){ + for (int i = 0;i < localSupplement.length;i++){ + if (localSupplement[i] != null){ + localSupplement[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureLocation")); + + + if (localCreateSignatureLocation==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureLocation cannot be null!!"); + } + elementList.add(localCreateSignatureLocation); + if (localSupplementTracker){ + if (localSupplement!=null) { + for (int i = 0;i < localSupplement.length;i++){ + + if (localSupplement[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Supplement")); + elementList.add(localSupplement[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureEnvironmentProfile_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureEnvironmentProfile_type0 object = + new CreateSignatureEnvironmentProfile_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateSignatureEnvironmentProfile_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateSignatureEnvironmentProfile_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureLocation").equals(reader.getName())){ + + object.setCreateSignatureLocation(CreateSignatureLocationType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSupplement((XMLDataObjectAssociationType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + XMLDataObjectAssociationType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Structure_type1 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "Structure_type1", + "ns2"); + + + + /** + * field for Structure_type1 + */ + + + protected java.lang.String localStructure_type1 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Structure_type1(java.lang.String value, boolean isRegisterValue) { + localStructure_type1 = value; + if (isRegisterValue){ + + _table_.put(localStructure_type1, this); + + } + + } + + public static final java.lang.String _detached = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("detached"); + + public static final java.lang.String _enveloping = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("enveloping"); + + public static final Structure_type1 detached = + new Structure_type1(_detached,true); + + public static final Structure_type1 enveloping = + new Structure_type1(_enveloping,true); + + + public java.lang.String getValue() { return localStructure_type1;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localStructure_type1.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":Structure_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "Structure_type1", + xmlWriter); + } + } + + if (localStructure_type1==null){ + + throw new org.apache.axis2.databinding.ADBException("Structure_type1 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localStructure_type1); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStructure_type1) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Structure_type1 fromValue(java.lang.String value) + throws java.lang.IllegalArgumentException { + Structure_type1 enumeration = (Structure_type1) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Structure_type1 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Structure_type1 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Structure_type1.Factory.fromString(content,namespaceUri); + } else { + return Structure_type1.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Structure_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Structure_type1 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Structure_type1" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Structure_type1.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Structure_type1.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class InputDataType extends ContentExLocRefBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = InputDataType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for PartOf + * This was an Attribute! + */ + + + protected PartOf_type0 localPartOf ; + + + /** + * Auto generated getter method + * @return PartOf_type0 + */ + public PartOf_type0 getPartOf(){ + return localPartOf; + } + + + + /** + * Auto generated setter method + * @param param PartOf + */ + public void setPartOf(PartOf_type0 param){ + + this.localPartOf=param; + + + } + + + /** + * field for ReferringSigReference + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localReferringSigReference ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getReferringSigReference(){ + return localReferringSigReference; + } + + + + /** + * Auto generated setter method + * @param param ReferringSigReference + */ + public void setReferringSigReference(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localReferringSigReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":InputDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "InputDataType", + xmlWriter); + } + + + + if (localPartOf != null){ + writeAttribute("", + "PartOf", + localPartOf.toString(), xmlWriter); + } + + if (localReferringSigReference != null){ + + writeAttribute("", + "ReferringSigReference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference), xmlWriter); + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","InputDataType")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","PartOf")); + + attribList.add(localPartOf.toString()); + + attribList.add( + new javax.xml.namespace.QName("","ReferringSigReference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static InputDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + InputDataType object = + new InputDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"InputDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (InputDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "PartOf" + java.lang.String tempAttribPartOf = + + reader.getAttributeValue(null,"PartOf"); + + if (tempAttribPartOf!=null){ + java.lang.String content = tempAttribPartOf; + + object.setPartOf( + PartOf_type0.Factory.fromString(reader,tempAttribPartOf)); + + } else { + + } + handledAttributes.add("PartOf"); + + // handle attribute "ReferringSigReference" + java.lang.String tempAttribReferringSigReference = + + reader.getAttributeValue(null,"ReferringSigReference"); + + if (tempAttribReferringSigReference!=null){ + java.lang.String content = tempAttribReferringSigReference; + + object.setReferringSigReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(tempAttribReferringSigReference)); + + } else { + + } + handledAttributes.add("ReferringSigReference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Structure_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "Structure_type0", + "ns2"); + + + + /** + * field for Structure_type0 + */ + + + protected java.lang.String localStructure_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Structure_type0(java.lang.String value, boolean isRegisterValue) { + localStructure_type0 = value; + if (isRegisterValue){ + + _table_.put(localStructure_type0, this); + + } + + } + + public static final java.lang.String _detached = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("detached"); + + public static final java.lang.String _enveloping = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("enveloping"); + + public static final Structure_type0 detached = + new Structure_type0(_detached,true); + + public static final Structure_type0 enveloping = + new Structure_type0(_enveloping,true); + + + public java.lang.String getValue() { return localStructure_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localStructure_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":Structure_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "Structure_type0", + xmlWriter); + } + } + + if (localStructure_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("Structure_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localStructure_type0); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStructure_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Structure_type0 fromValue(java.lang.String value) + throws java.lang.IllegalArgumentException { + Structure_type0 enumeration = (Structure_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Structure_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Structure_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Structure_type0.Factory.fromString(content,namespaceUri); + } else { + return Structure_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Structure_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Structure_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Structure_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Structure_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Structure_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureEnvironment_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureEnvironment_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureEnvironment_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureEnvironment_type0", + xmlWriter); + } + + + } + + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureEnvironment_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureEnvironment_type0 object = + new SignatureEnvironment_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureEnvironment_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureEnvironment_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RSAKeyValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "RSAKeyValue", + "ns1"); + + + + /** + * field for RSAKeyValue + */ + + + protected RSAKeyValueType localRSAKeyValue ; + + + /** + * Auto generated getter method + * @return RSAKeyValueType + */ + public RSAKeyValueType getRSAKeyValue(){ + return localRSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param RSAKeyValue + */ + public void setRSAKeyValue(RSAKeyValueType param){ + + this.localRSAKeyValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localRSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("RSAKeyValue cannot be null!"); + } + localRSAKeyValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localRSAKeyValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RSAKeyValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RSAKeyValue object = + new RSAKeyValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RSAKeyValue").equals(reader.getName())){ + + object.setRSAKeyValue(RSAKeyValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestValueType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DigestValueType", + "ns1"); + + + + /** + * field for DigestValueType + */ + + + protected javax.activation.DataHandler localDigestValueType ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getDigestValueType(){ + return localDigestValueType; + } + + + + /** + * Auto generated setter method + * @param param DigestValueType + */ + public void setDigestValueType(javax.activation.DataHandler param){ + + this.localDigestValueType=param; + + + } + + + public java.lang.String toString(){ + + return localDigestValueType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DigestValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DigestValueType", + xmlWriter); + } + } + + if (localDigestValueType==null){ + + throw new org.apache.axis2.databinding.ADBException("DigestValueType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDigestValueType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDigestValueType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static DigestValueType fromString(java.lang.String value, + java.lang.String namespaceURI){ + DigestValueType returnValue = new DigestValueType(); + + returnValue.setDigestValueType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(value)); + + + return returnValue; + } + + public static DigestValueType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return DigestValueType.Factory.fromString(content,namespaceUri); + } else { + return DigestValueType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestValueType object = + new DigestValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DigestValueType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDigestValueType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Signature + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Signature", + "ns1"); + + + + /** + * field for Signature + */ + + + protected SignatureType localSignature ; + + + /** + * Auto generated getter method + * @return SignatureType + */ + public SignatureType getSignature(){ + return localSignature; + } + + + + /** + * Auto generated setter method + * @param param Signature + */ + public void setSignature(SignatureType param){ + + this.localSignature=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignature==null){ + throw new org.apache.axis2.databinding.ADBException("Signature cannot be null!"); + } + localSignature.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignature.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Signature parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Signature object = + new Signature(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Signature").equals(reader.getName())){ + + object.setSignature(SignatureType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfo_type1 extends CMSDataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfo_type1 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfo_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfo_type1", + xmlWriter); + } + + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo_type1")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfo_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfo_type1 object = + new DataObjectInfo_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObjectInfo_type1".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObjectInfo_type1)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type1.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type1.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfo_type0 extends DataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ChildOfManifest + * This was an Attribute! + */ + + + protected boolean localChildOfManifest = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("false"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getChildOfManifest(){ + return localChildOfManifest; + } + + + + /** + * Auto generated setter method + * @param param ChildOfManifest + */ + public void setChildOfManifest(boolean param){ + + this.localChildOfManifest=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfo_type0", + xmlWriter); + } + + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (true) { + + writeAttribute("", + "ChildOfManifest", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localChildOfManifest), xmlWriter); + + + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + localDataObjectInfoTypeChoice_type0.serialize(null,xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo_type0")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfoTypeChoice_type0")); + + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + elementList.add(localDataObjectInfoTypeChoice_type0); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + attribList.add( + new javax.xml.namespace.QName("","ChildOfManifest")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localChildOfManifest)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfo_type0 object = + new DataObjectInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObjectInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObjectInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type0.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + // handle attribute "ChildOfManifest" + java.lang.String tempAttribChildOfManifest = + + reader.getAttributeValue(null,"ChildOfManifest"); + + if (tempAttribChildOfManifest!=null){ + java.lang.String content = tempAttribChildOfManifest; + + object.setChildOfManifest( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribChildOfManifest)); + + } else { + + } + handledAttributes.add("ChildOfManifest"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() ){ + + object.setDataObjectInfoTypeChoice_type0(DataObjectInfoTypeChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValue", + "ns1"); + + + + /** + * field for DSAKeyValue + */ + + + protected DSAKeyValueType localDSAKeyValue ; + + + /** + * Auto generated getter method + * @return DSAKeyValueType + */ + public DSAKeyValueType getDSAKeyValue(){ + return localDSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValue + */ + public void setDSAKeyValue(DSAKeyValueType param){ + + this.localDSAKeyValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localDSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValue cannot be null!"); + } + localDSAKeyValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localDSAKeyValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValue object = + new DSAKeyValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DSAKeyValue").equals(reader.getName())){ + + object.setDSAKeyValue(DSAKeyValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ReferenceType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ReferenceType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for DigestMethod + */ + + + protected DigestMethodType localDigestMethod ; + + + /** + * Auto generated getter method + * @return DigestMethodType + */ + public DigestMethodType getDigestMethod(){ + return localDigestMethod; + } + + + + /** + * Auto generated setter method + * @param param DigestMethod + */ + public void setDigestMethod(DigestMethodType param){ + + this.localDigestMethod=param; + + + } + + + /** + * field for DigestValue + */ + + + protected DigestValueType localDigestValue ; + + + /** + * Auto generated getter method + * @return DigestValueType + */ + public DigestValueType getDigestValue(){ + return localDigestValue; + } + + + + /** + * Auto generated setter method + * @param param DigestValue + */ + public void setDigestValue(DigestValueType param){ + + this.localDigestValue=param; + + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + /** + * field for URI + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localURI ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getURI(){ + return localURI; + } + + + + /** + * Auto generated setter method + * @param param URI + */ + public void setURI(org.apache.axis2.databinding.types.URI param){ + + this.localURI=param; + + + } + + + /** + * field for Type + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getType(){ + return localType; + } + + + + /** + * Auto generated setter method + * @param param Type + */ + public void setType(org.apache.axis2.databinding.types.URI param){ + + this.localType=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ReferenceType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ReferenceType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localURI != null){ + + writeAttribute("", + "URI", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI), xmlWriter); + + + } + + if (localType != null){ + + writeAttribute("", + "Type", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType), xmlWriter); + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + localDigestMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod"), + xmlWriter); + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + localDigestValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestMethod")); + + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + elementList.add(localDigestMethod); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestValue")); + + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + elementList.add(localDigestValue); + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + attribList.add( + new javax.xml.namespace.QName("","URI")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI)); + + attribList.add( + new javax.xml.namespace.QName("","Type")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ReferenceType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ReferenceType object = + new ReferenceType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ReferenceType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ReferenceType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + // handle attribute "URI" + java.lang.String tempAttribURI = + + reader.getAttributeValue(null,"URI"); + + if (tempAttribURI!=null){ + java.lang.String content = tempAttribURI; + + object.setURI( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribURI)); + + } else { + + } + handledAttributes.add("URI"); + + // handle attribute "Type" + java.lang.String tempAttribType = + + reader.getAttributeValue(null,"Type"); + + if (tempAttribType!=null){ + java.lang.String content = tempAttribType; + + object.setType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribType)); + + } else { + + } + handledAttributes.add("Type"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod").equals(reader.getName())){ + + object.setDigestMethod(DigestMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue").equals(reader.getName())){ + + object.setDigestValue(DigestValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = KeyInfoType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for KeyInfoTypeChoice + * This was an Array! + */ + + + protected KeyInfoTypeChoice[] localKeyInfoTypeChoice ; + + + /** + * Auto generated getter method + * @return KeyInfoTypeChoice[] + */ + public KeyInfoTypeChoice[] getKeyInfoTypeChoice(){ + return localKeyInfoTypeChoice; + } + + + + + + + /** + * validate the array for KeyInfoTypeChoice + */ + protected void validateKeyInfoTypeChoice(KeyInfoTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param KeyInfoTypeChoice + */ + public void setKeyInfoTypeChoice(KeyInfoTypeChoice[] param){ + + validateKeyInfoTypeChoice(param); + + + this.localKeyInfoTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param KeyInfoTypeChoice + */ + public void addKeyInfoTypeChoice(KeyInfoTypeChoice param){ + if (localKeyInfoTypeChoice == null){ + localKeyInfoTypeChoice = new KeyInfoTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localKeyInfoTypeChoice); + list.add(param); + this.localKeyInfoTypeChoice = + (KeyInfoTypeChoice[])list.toArray( + new KeyInfoTypeChoice[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyInfoType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + + if (localKeyInfoTypeChoice!=null){ + for (int i = 0;i < localKeyInfoTypeChoice.length;i++){ + if (localKeyInfoTypeChoice[i] != null){ + localKeyInfoTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localKeyInfoTypeChoice!=null) { + for (int i = 0;i < localKeyInfoTypeChoice.length;i++){ + + if (localKeyInfoTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyInfoTypeChoice")); + elementList.add(localKeyInfoTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyInfoType object = + new KeyInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"KeyInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (KeyInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(KeyInfoTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(KeyInfoTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setKeyInfoTypeChoice((KeyInfoTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + KeyInfoTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsDataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyTransformsDataType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for VerifyTransformsDataTypeChoice + * This was an Array! + */ + + + protected VerifyTransformsDataTypeChoice[] localVerifyTransformsDataTypeChoice ; + + + /** + * Auto generated getter method + * @return VerifyTransformsDataTypeChoice[] + */ + public VerifyTransformsDataTypeChoice[] getVerifyTransformsDataTypeChoice(){ + return localVerifyTransformsDataTypeChoice; + } + + + + + + + /** + * validate the array for VerifyTransformsDataTypeChoice + */ + protected void validateVerifyTransformsDataTypeChoice(VerifyTransformsDataTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param VerifyTransformsDataTypeChoice + */ + public void setVerifyTransformsDataTypeChoice(VerifyTransformsDataTypeChoice[] param){ + + validateVerifyTransformsDataTypeChoice(param); + + + this.localVerifyTransformsDataTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyTransformsDataTypeChoice + */ + public void addVerifyTransformsDataTypeChoice(VerifyTransformsDataTypeChoice param){ + if (localVerifyTransformsDataTypeChoice == null){ + localVerifyTransformsDataTypeChoice = new VerifyTransformsDataTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localVerifyTransformsDataTypeChoice); + list.add(param); + this.localVerifyTransformsDataTypeChoice = + (VerifyTransformsDataTypeChoice[])list.toArray( + new VerifyTransformsDataTypeChoice[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyTransformsDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyTransformsDataType", + xmlWriter); + } + + + } + + + if (localVerifyTransformsDataTypeChoice!=null){ + for (int i = 0;i < localVerifyTransformsDataTypeChoice.length;i++){ + if (localVerifyTransformsDataTypeChoice[i] != null){ + localVerifyTransformsDataTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localVerifyTransformsDataTypeChoice!=null) { + for (int i = 0;i < localVerifyTransformsDataTypeChoice.length;i++){ + + if (localVerifyTransformsDataTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsDataTypeChoice")); + elementList.add(localVerifyTransformsDataTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsDataType object = + new VerifyTransformsDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyTransformsDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyTransformsDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(VerifyTransformsDataTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(VerifyTransformsDataTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setVerifyTransformsDataTypeChoice((VerifyTransformsDataTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyTransformsDataTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DigestMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DigestMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DigestMethodType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestMethodType object = + new DigestMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DigestMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DigestMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class AllSignatoriesType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "AllSignatoriesType", + "ns2"); + + + + /** + * field for AllSignatoriesType + */ + + + protected java.lang.String localAllSignatoriesType ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected AllSignatoriesType(java.lang.String value, boolean isRegisterValue) { + localAllSignatoriesType = value; + if (isRegisterValue){ + + _table_.put(localAllSignatoriesType, this); + + } + + } + + public static final java.lang.String _all = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("all"); + + public static final AllSignatoriesType all = + new AllSignatoriesType(_all,true); + + + public java.lang.String getValue() { return localAllSignatoriesType;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localAllSignatoriesType.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":AllSignatoriesType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "AllSignatoriesType", + xmlWriter); + } + } + + if (localAllSignatoriesType==null){ + + throw new org.apache.axis2.databinding.ADBException("AllSignatoriesType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localAllSignatoriesType); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllSignatoriesType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static AllSignatoriesType fromValue(java.lang.String value) + throws java.lang.IllegalArgumentException { + AllSignatoriesType enumeration = (AllSignatoriesType) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static AllSignatoriesType fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static AllSignatoriesType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return AllSignatoriesType.Factory.fromString(content,namespaceUri); + } else { + return AllSignatoriesType.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static AllSignatoriesType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + AllSignatoriesType object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"AllSignatoriesType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = AllSignatoriesType.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = AllSignatoriesType.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformsInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformsInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for FinalDataMetaInfo + */ + + + protected FinalDataMetaInfoType localFinalDataMetaInfo ; + + + /** + * Auto generated getter method + * @return FinalDataMetaInfoType + */ + public FinalDataMetaInfoType getFinalDataMetaInfo(){ + return localFinalDataMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param FinalDataMetaInfo + */ + public void setFinalDataMetaInfo(FinalDataMetaInfoType param){ + + this.localFinalDataMetaInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformsInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformsInfoType", + xmlWriter); + } + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } + if (localFinalDataMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("FinalDataMetaInfo cannot be null!!"); + } + localFinalDataMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FinalDataMetaInfo"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "FinalDataMetaInfo")); + + + if (localFinalDataMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("FinalDataMetaInfo cannot be null!!"); + } + elementList.add(localFinalDataMetaInfo); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformsInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformsInfoType object = + new TransformsInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformsInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformsInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FinalDataMetaInfo").equals(reader.getName())){ + + object.setFinalDataMetaInfo(FinalDataMetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentExLocRefBaseType extends ContentBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentExLocRefBaseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localXMLContentTracker = false; + + localLocRefContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for XMLContent + */ + + + protected XMLContentType localXMLContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLContentTracker = false ; + + public boolean isXMLContentSpecified(){ + return localXMLContentTracker; + } + + + + /** + * Auto generated getter method + * @return XMLContentType + */ + public XMLContentType getXMLContent(){ + return localXMLContent; + } + + + + /** + * Auto generated setter method + * @param param XMLContent + */ + public void setXMLContent(XMLContentType param){ + + clearAllSettingTrackers(); + localXMLContentTracker = param != null; + + this.localXMLContent=param; + + + } + + + /** + * Auto generated getter method + * Overridden from ContentBaseType + * + * @throws RuntimeException + */ + public org.apache.axis2.databinding.types.URI getLocRefContent(){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + /** + * Auto generated setter method + * Overridden from ContentBaseType + * + * @param param LocRefContent + * @throws RuntimeException + */ + public void setLocRefContent(org.apache.axis2.databinding.types.URI param){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentExLocRefBaseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentExLocRefBaseType", + xmlWriter); + } + + + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localXMLContentTracker){ + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + } if (localLocRefContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localXMLContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + } if (localLocRefContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentExLocRefBaseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentExLocRefBaseType object = + new ContentExLocRefBaseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentExLocRefBaseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentExLocRefBaseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateXMLSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for KeyIdentifier + */ + + + protected KeyIdentifierType localKeyIdentifier ; + + + /** + * Auto generated getter method + * @return KeyIdentifierType + */ + public KeyIdentifierType getKeyIdentifier(){ + return localKeyIdentifier; + } + + + + /** + * Auto generated setter method + * @param param KeyIdentifier + */ + public void setKeyIdentifier(KeyIdentifierType param){ + + this.localKeyIdentifier=param; + + + } + + + /** + * field for SingleSignatureInfo + * This was an Array! + */ + + + protected SingleSignatureInfo_type0[] localSingleSignatureInfo ; + + + /** + * Auto generated getter method + * @return SingleSignatureInfo_type0[] + */ + public SingleSignatureInfo_type0[] getSingleSignatureInfo(){ + return localSingleSignatureInfo; + } + + + + + + + /** + * validate the array for SingleSignatureInfo + */ + protected void validateSingleSignatureInfo(SingleSignatureInfo_type0[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SingleSignatureInfo + */ + public void setSingleSignatureInfo(SingleSignatureInfo_type0[] param){ + + validateSingleSignatureInfo(param); + + + this.localSingleSignatureInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SingleSignatureInfo_type0 + */ + public void addSingleSignatureInfo(SingleSignatureInfo_type0 param){ + if (localSingleSignatureInfo == null){ + localSingleSignatureInfo = new SingleSignatureInfo_type0[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSingleSignatureInfo); + list.add(param); + this.localSingleSignatureInfo = + (SingleSignatureInfo_type0[])list.toArray( + new SingleSignatureInfo_type0[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureRequestType", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureRequestType object = + new CreateXMLSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateXMLSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateXMLSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type0.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsDataTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyTransformsDataTypeChoice + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localVerifyTransformsInfoProfileTracker = false; + + localVerifyTransformsInfoProfileIDTracker = false; + + } + + + /** + * field for VerifyTransformsInfoProfile + */ + + + protected VerifyTransformsInfoProfile_type0 localVerifyTransformsInfoProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localVerifyTransformsInfoProfileTracker = false ; + + public boolean isVerifyTransformsInfoProfileSpecified(){ + return localVerifyTransformsInfoProfileTracker; + } + + + + /** + * Auto generated getter method + * @return VerifyTransformsInfoProfile_type0 + */ + public VerifyTransformsInfoProfile_type0 getVerifyTransformsInfoProfile(){ + return localVerifyTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param VerifyTransformsInfoProfile + */ + public void setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0 param){ + + clearAllSettingTrackers(); + localVerifyTransformsInfoProfileTracker = param != null; + + this.localVerifyTransformsInfoProfile=param; + + + } + + + /** + * field for VerifyTransformsInfoProfileID + */ + + + protected java.lang.String localVerifyTransformsInfoProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localVerifyTransformsInfoProfileIDTracker = false ; + + public boolean isVerifyTransformsInfoProfileIDSpecified(){ + return localVerifyTransformsInfoProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getVerifyTransformsInfoProfileID(){ + return localVerifyTransformsInfoProfileID; + } + + + + /** + * Auto generated setter method + * @param param VerifyTransformsInfoProfileID + */ + public void setVerifyTransformsInfoProfileID(java.lang.String param){ + + clearAllSettingTrackers(); + localVerifyTransformsInfoProfileIDTracker = param != null; + + this.localVerifyTransformsInfoProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyTransformsDataTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyTransformsDataTypeChoice", + xmlWriter); + } + + + } + if (localVerifyTransformsInfoProfileTracker){ + if (localVerifyTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfile cannot be null!!"); + } + localVerifyTransformsInfoProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfile"), + xmlWriter); + } if (localVerifyTransformsInfoProfileIDTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "VerifyTransformsInfoProfileID", xmlWriter); + + + if (localVerifyTransformsInfoProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localVerifyTransformsInfoProfileID); + + } + + xmlWriter.writeEndElement(); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localVerifyTransformsInfoProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsInfoProfile")); + + + if (localVerifyTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfile cannot be null!!"); + } + elementList.add(localVerifyTransformsInfoProfile); + } if (localVerifyTransformsInfoProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsInfoProfileID")); + + if (localVerifyTransformsInfoProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localVerifyTransformsInfoProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfileID cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsDataTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsDataTypeChoice object = + new VerifyTransformsDataTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfile").equals(reader.getName())){ + + object.setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"VerifyTransformsInfoProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setVerifyTransformsInfoProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SPKIDataTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SPKIDataTypeSequence + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SPKISexp + */ + + + protected javax.activation.DataHandler localSPKISexp ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getSPKISexp(){ + return localSPKISexp; + } + + + + /** + * Auto generated setter method + * @param param SPKISexp + */ + public void setSPKISexp(javax.activation.DataHandler param){ + + this.localSPKISexp=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SPKIDataTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SPKIDataTypeSequence", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "SPKISexp", xmlWriter); + + + if (localSPKISexp!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localSPKISexp, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for SPKISexp", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SPKISexp")); + + elementList.add(localSPKISexp); + if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SPKIDataTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SPKIDataTypeSequence object = + new SPKIDataTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKISexp").equals(reader.getName())){ + + object.setSPKISexp(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname2 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder2 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname2); + object.setExtraElement(builder2.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Base64Binary + */ + + + protected javax.activation.DataHandler localBase64Binary ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Binary(){ + return localBase64Binary; + } + + + + /** + * Auto generated setter method + * @param param Base64Binary + */ + public void setBase64Binary(javax.activation.DataHandler param){ + + this.localBase64Binary=param; + + + } + + + public java.lang.String toString(){ + + return localBase64Binary.toString(); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureValueType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + + if (localBase64Binary!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Binary, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for base64Binary", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT); + + elementList.add(localBase64Binary); + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static SignatureValueType fromString(java.lang.String value, + java.lang.String namespaceURI){ + SignatureValueType returnValue = new SignatureValueType(); + + returnValue.setBase64Binary( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(value)); + + + return returnValue; + } + + public static SignatureValueType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return SignatureValueType.Factory.fromString(content,namespaceUri); + } else { + return SignatureValueType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureValueType object = + new SignatureValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + object.setBase64Binary(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureValue", + "ns1"); + + + + /** + * field for SignatureValue + */ + + + protected SignatureValueType localSignatureValue ; + + + /** + * Auto generated getter method + * @return SignatureValueType + */ + public SignatureValueType getSignatureValue(){ + return localSignatureValue; + } + + + + /** + * Auto generated setter method + * @param param SignatureValue + */ + public void setSignatureValue(SignatureValueType param){ + + this.localSignatureValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureValue==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureValue cannot be null!"); + } + localSignatureValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureValue object = + new SignatureValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureValue").equals(reader.getName())){ + + object.setSignatureValue(SignatureValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformParameterType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformParameterType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localHashTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for Hash + */ + + + protected Hash_type0 localHash ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localHashTracker = false ; + + public boolean isHashSpecified(){ + return localHashTracker; + } + + + + /** + * Auto generated getter method + * @return Hash_type0 + */ + public Hash_type0 getHash(){ + return localHash; + } + + + + /** + * Auto generated setter method + * @param param Hash + */ + public void setHash(Hash_type0 param){ + + clearAllSettingTrackers(); + localHashTracker = param != null; + + this.localHash=param; + + + } + + + /** + * field for URI + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localURI ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localURITracker = false ; + + public boolean isURISpecified(){ + return localURITracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getURI(){ + return localURI; + } + + + + /** + * Auto generated setter method + * @param param URI + */ + public void setURI(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localURITracker = param != null; + + this.localURI=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformParameterType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformParameterType", + xmlWriter); + } + + + } + + if (localURI != null){ + + writeAttribute("", + "URI", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localURI is null"); + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localHashTracker){ + if (localHash==null){ + throw new org.apache.axis2.databinding.ADBException("Hash cannot be null!!"); + } + localHash.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Hash"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localHashTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Hash")); + + + if (localHash==null){ + throw new org.apache.axis2.databinding.ADBException("Hash cannot be null!!"); + } + elementList.add(localHash); + } + attribList.add( + new javax.xml.namespace.QName("","URI")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformParameterType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformParameterType object = + new TransformParameterType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformParameterType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformParameterType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "URI" + java.lang.String tempAttribURI = + + reader.getAttributeValue(null,"URI"); + + if (tempAttribURI!=null){ + java.lang.String content = tempAttribURI; + + object.setURI( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribURI)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute URI is missing"); + + } + handledAttributes.add("URI"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Hash").equals(reader.getName())){ + + object.setHash(Hash_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ManifestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ManifestType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Reference + * This was an Array! + */ + + + protected ReferenceType[] localReference ; + + + /** + * Auto generated getter method + * @return ReferenceType[] + */ + public ReferenceType[] getReference(){ + return localReference; + } + + + + + + + /** + * validate the array for Reference + */ + protected void validateReference(ReferenceType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(ReferenceType[] param){ + + validateReference(param); + + + this.localReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ReferenceType + */ + public void addReference(ReferenceType param){ + if (localReference == null){ + localReference = new ReferenceType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReference); + list.add(param); + this.localReference = + (ReferenceType[])list.toArray( + new ReferenceType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ManifestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ManifestType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localReference!=null){ + for (int i = 0;i < localReference.length;i++){ + if (localReference[i] != null){ + localReference[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localReference!=null) { + for (int i = 0;i < localReference.length;i++){ + + if (localReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Reference")); + elementList.add(localReference[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ManifestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ManifestType object = + new ManifestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ManifestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ManifestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(ReferenceType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + list1.add(ReferenceType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReference((ReferenceType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ReferenceType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Transform + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Transform", + "ns1"); + + + + /** + * field for Transform + */ + + + protected TransformType localTransform ; + + + /** + * Auto generated getter method + * @return TransformType + */ + public TransformType getTransform(){ + return localTransform; + } + + + + /** + * Auto generated setter method + * @param param Transform + */ + public void setTransform(TransformType param){ + + this.localTransform=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localTransform==null){ + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!"); + } + localTransform.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localTransform.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Transform parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Transform object = + new Transform(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform").equals(reader.getName())){ + + object.setTransform(TransformType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class HMACOutputLengthType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "HMACOutputLengthType", + "ns1"); + + + + /** + * field for HMACOutputLengthType + */ + + + protected java.math.BigInteger localHMACOutputLengthType ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getHMACOutputLengthType(){ + return localHMACOutputLengthType; + } + + + + /** + * Auto generated setter method + * @param param HMACOutputLengthType + */ + public void setHMACOutputLengthType(java.math.BigInteger param){ + + this.localHMACOutputLengthType=param; + + + } + + + public java.lang.String toString(){ + + return localHMACOutputLengthType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":HMACOutputLengthType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "HMACOutputLengthType", + xmlWriter); + } + } + + if (localHMACOutputLengthType==null){ + + throw new org.apache.axis2.databinding.ADBException("HMACOutputLengthType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHMACOutputLengthType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHMACOutputLengthType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static HMACOutputLengthType fromString(java.lang.String value, + java.lang.String namespaceURI){ + HMACOutputLengthType returnValue = new HMACOutputLengthType(); + + returnValue.setHMACOutputLengthType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(value)); + + + return returnValue; + } + + public static HMACOutputLengthType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return HMACOutputLengthType.Factory.fromString(content,namespaceUri); + } else { + return HMACOutputLengthType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static HMACOutputLengthType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + HMACOutputLengthType object = + new HMACOutputLengthType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"HMACOutputLengthType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setHMACOutputLengthType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureLocationType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureLocationType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Token + */ + + + protected org.apache.axis2.databinding.types.Token localToken ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getToken(){ + return localToken; + } + + + + /** + * Auto generated setter method + * @param param Token + */ + public void setToken(org.apache.axis2.databinding.types.Token param){ + + this.localToken=param; + + + } + + + public java.lang.String toString(){ + + return localToken.toString(); + + } + + + /** + * field for Index + * This was an Attribute! + */ + + + protected java.math.BigInteger localIndex ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getIndex(){ + return localIndex; + } + + + + /** + * Auto generated setter method + * @param param Index + */ + public void setIndex(java.math.BigInteger param){ + + this.localIndex=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureLocationType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureLocationType", + xmlWriter); + } + + + } + + if (localIndex != null){ + + writeAttribute("", + "Index", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIndex), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localIndex is null"); + } + + + if (localToken==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("token cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localToken)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + + elementList.add(org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT); + + if (localToken != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localToken)); + } else { + throw new org.apache.axis2.databinding.ADBException("token cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Index")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIndex)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static CreateSignatureLocationType fromString(java.lang.String value, + java.lang.String namespaceURI){ + CreateSignatureLocationType returnValue = new CreateSignatureLocationType(); + + returnValue.setToken( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + return returnValue; + } + + public static CreateSignatureLocationType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return CreateSignatureLocationType.Factory.fromString(content,namespaceUri); + } else { + return CreateSignatureLocationType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureLocationType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureLocationType object = + new CreateSignatureLocationType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateSignatureLocationType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateSignatureLocationType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Index" + java.lang.String tempAttribIndex = + + reader.getAttributeValue(null,"Index"); + + if (tempAttribIndex!=null){ + java.lang.String content = tempAttribIndex; + + object.setIndex( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(tempAttribIndex)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Index is missing"); + + } + handledAttributes.add("Index"); + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"token" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setToken( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformsType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformsType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Transform + * This was an Array! + */ + + + protected TransformType[] localTransform ; + + + /** + * Auto generated getter method + * @return TransformType[] + */ + public TransformType[] getTransform(){ + return localTransform; + } + + + + + + + /** + * validate the array for Transform + */ + protected void validateTransform(TransformType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param Transform + */ + public void setTransform(TransformType[] param){ + + validateTransform(param); + + + this.localTransform=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param TransformType + */ + public void addTransform(TransformType param){ + if (localTransform == null){ + localTransform = new TransformType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localTransform); + list.add(param); + this.localTransform = + (TransformType[])list.toArray( + new TransformType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformsType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformsType", + xmlWriter); + } + + + } + + if (localTransform!=null){ + for (int i = 0;i < localTransform.length;i++){ + if (localTransform[i] != null){ + localTransform[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localTransform!=null) { + for (int i = 0;i < localTransform.length;i++){ + + if (localTransform[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transform")); + elementList.add(localTransform[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformsType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformsType object = + new TransformsType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformsType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformsType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(TransformType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform").equals(reader.getName())){ + list1.add(TransformType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setTransform((TransformType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + TransformType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateXMLSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateXMLSignatureResponseTypeChoice + * This was an Array! + */ + + + protected CreateXMLSignatureResponseTypeChoice[] localCreateXMLSignatureResponseTypeChoice ; + + + /** + * Auto generated getter method + * @return CreateXMLSignatureResponseTypeChoice[] + */ + public CreateXMLSignatureResponseTypeChoice[] getCreateXMLSignatureResponseTypeChoice(){ + return localCreateXMLSignatureResponseTypeChoice; + } + + + + + + + /** + * validate the array for CreateXMLSignatureResponseTypeChoice + */ + protected void validateCreateXMLSignatureResponseTypeChoice(CreateXMLSignatureResponseTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param CreateXMLSignatureResponseTypeChoice + */ + public void setCreateXMLSignatureResponseTypeChoice(CreateXMLSignatureResponseTypeChoice[] param){ + + validateCreateXMLSignatureResponseTypeChoice(param); + + + this.localCreateXMLSignatureResponseTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param CreateXMLSignatureResponseTypeChoice + */ + public void addCreateXMLSignatureResponseTypeChoice(CreateXMLSignatureResponseTypeChoice param){ + if (localCreateXMLSignatureResponseTypeChoice == null){ + localCreateXMLSignatureResponseTypeChoice = new CreateXMLSignatureResponseTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localCreateXMLSignatureResponseTypeChoice); + list.add(param); + this.localCreateXMLSignatureResponseTypeChoice = + (CreateXMLSignatureResponseTypeChoice[])list.toArray( + new CreateXMLSignatureResponseTypeChoice[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureResponseType", + xmlWriter); + } + + + } + + + if (localCreateXMLSignatureResponseTypeChoice!=null){ + for (int i = 0;i < localCreateXMLSignatureResponseTypeChoice.length;i++){ + if (localCreateXMLSignatureResponseTypeChoice[i] != null){ + localCreateXMLSignatureResponseTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localCreateXMLSignatureResponseTypeChoice!=null) { + for (int i = 0;i < localCreateXMLSignatureResponseTypeChoice.length;i++){ + + if (localCreateXMLSignatureResponseTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateXMLSignatureResponseTypeChoice")); + elementList.add(localCreateXMLSignatureResponseTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureResponseType object = + new CreateXMLSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateXMLSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateXMLSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(CreateXMLSignatureResponseTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(CreateXMLSignatureResponseTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setCreateXMLSignatureResponseTypeChoice((CreateXMLSignatureResponseTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + CreateXMLSignatureResponseTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateTransformsInfoProfile_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateTransformsInfoProfile_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateTransformsInfo + */ + + + protected TransformsInfoType localCreateTransformsInfo ; + + + /** + * Auto generated getter method + * @return TransformsInfoType + */ + public TransformsInfoType getCreateTransformsInfo(){ + return localCreateTransformsInfo; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfo + */ + public void setCreateTransformsInfo(TransformsInfoType param){ + + this.localCreateTransformsInfo=param; + + + } + + + /** + * field for Supplement + * This was an Array! + */ + + + protected XMLDataObjectAssociationType[] localSupplement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementTracker = false ; + + public boolean isSupplementSpecified(){ + return localSupplementTracker; + } + + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType[] + */ + public XMLDataObjectAssociationType[] getSupplement(){ + return localSupplement; + } + + + + + + + /** + * validate the array for Supplement + */ + protected void validateSupplement(XMLDataObjectAssociationType[] param){ + + } + + + /** + * Auto generated setter method + * @param param Supplement + */ + public void setSupplement(XMLDataObjectAssociationType[] param){ + + validateSupplement(param); + + localSupplementTracker = param != null; + + this.localSupplement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param XMLDataObjectAssociationType + */ + public void addSupplement(XMLDataObjectAssociationType param){ + if (localSupplement == null){ + localSupplement = new XMLDataObjectAssociationType[]{}; + } + + + //update the setting tracker + localSupplementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSupplement); + list.add(param); + this.localSupplement = + (XMLDataObjectAssociationType[])list.toArray( + new XMLDataObjectAssociationType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateTransformsInfoProfile_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateTransformsInfoProfile_type0", + xmlWriter); + } + + + } + + if (localCreateTransformsInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfo cannot be null!!"); + } + localCreateTransformsInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfo"), + xmlWriter); + if (localSupplementTracker){ + if (localSupplement!=null){ + for (int i = 0;i < localSupplement.length;i++){ + if (localSupplement[i] != null){ + localSupplement[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfo")); + + + if (localCreateTransformsInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfo cannot be null!!"); + } + elementList.add(localCreateTransformsInfo); + if (localSupplementTracker){ + if (localSupplement!=null) { + for (int i = 0;i < localSupplement.length;i++){ + + if (localSupplement[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Supplement")); + elementList.add(localSupplement[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateTransformsInfoProfile_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateTransformsInfoProfile_type0 object = + new CreateTransformsInfoProfile_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateTransformsInfoProfile_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateTransformsInfoProfile_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfo").equals(reader.getName())){ + + object.setCreateTransformsInfo(TransformsInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSupplement((XMLDataObjectAssociationType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + XMLDataObjectAssociationType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ErrorResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorResponse", + "ns2"); + + + + /** + * field for ErrorResponse + */ + + + protected ErrorResponseType localErrorResponse ; + + + /** + * Auto generated getter method + * @return ErrorResponseType + */ + public ErrorResponseType getErrorResponse(){ + return localErrorResponse; + } + + + + /** + * Auto generated setter method + * @param param ErrorResponse + */ + public void setErrorResponse(ErrorResponseType param){ + + this.localErrorResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!"); + } + localErrorResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localErrorResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ErrorResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ErrorResponse object = + new ErrorResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse").equals(reader.getName())){ + + object.setErrorResponse(ErrorResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Space_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/XML/1998/namespace", + "space_type0", + "ns3"); + + + + /** + * field for Space_type0 + */ + + + protected org.apache.axis2.databinding.types.NCName localSpace_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Space_type0(org.apache.axis2.databinding.types.NCName value, boolean isRegisterValue) { + localSpace_type0 = value; + if (isRegisterValue){ + + _table_.put(localSpace_type0, this); + + } + + } + + public static final org.apache.axis2.databinding.types.NCName _value1 = + org.apache.axis2.databinding.utils.ConverterUtil.convertToNCName("default"); + + public static final org.apache.axis2.databinding.types.NCName _value2 = + org.apache.axis2.databinding.utils.ConverterUtil.convertToNCName("preserve"); + + public static final Space_type0 value1 = + new Space_type0(_value1,true); + + public static final Space_type0 value2 = + new Space_type0(_value2,true); + + + public org.apache.axis2.databinding.types.NCName getValue() { return localSpace_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localSpace_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/XML/1998/namespace"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":space_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "space_type0", + xmlWriter); + } + } + + if (localSpace_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("space_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSpace_type0)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/XML/1998/namespace")){ + return "ns3"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSpace_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Space_type0 fromValue(org.apache.axis2.databinding.types.NCName value) + throws java.lang.IllegalArgumentException { + Space_type0 enumeration = (Space_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Space_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToNCName(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Space_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Space_type0.Factory.fromString(content,namespaceUri); + } else { + return Space_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Space_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Space_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"space_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Space_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Space_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyXMLSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DateTime + */ + + + protected java.util.Calendar localDateTime ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDateTimeTracker = false ; + + public boolean isDateTimeSpecified(){ + return localDateTimeTracker; + } + + + + /** + * Auto generated getter method + * @return java.util.Calendar + */ + public java.util.Calendar getDateTime(){ + return localDateTime; + } + + + + /** + * Auto generated setter method + * @param param DateTime + */ + public void setDateTime(java.util.Calendar param){ + localDateTimeTracker = param != null; + + this.localDateTime=param; + + + } + + + /** + * field for VerifySignatureInfo + */ + + + protected VerifySignatureInfo_type0 localVerifySignatureInfo ; + + + /** + * Auto generated getter method + * @return VerifySignatureInfo_type0 + */ + public VerifySignatureInfo_type0 getVerifySignatureInfo(){ + return localVerifySignatureInfo; + } + + + + /** + * Auto generated setter method + * @param param VerifySignatureInfo + */ + public void setVerifySignatureInfo(VerifySignatureInfo_type0 param){ + + this.localVerifySignatureInfo=param; + + + } + + + /** + * field for VerifyXMLSignatureRequestTypeChoice_type0 + * This was an Array! + */ + + + protected VerifyXMLSignatureRequestTypeChoice_type0[] localVerifyXMLSignatureRequestTypeChoice_type0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localVerifyXMLSignatureRequestTypeChoice_type0Tracker = false ; + + public boolean isVerifyXMLSignatureRequestTypeChoice_type0Specified(){ + return localVerifyXMLSignatureRequestTypeChoice_type0Tracker; + } + + + + /** + * Auto generated getter method + * @return VerifyXMLSignatureRequestTypeChoice_type0[] + */ + public VerifyXMLSignatureRequestTypeChoice_type0[] getVerifyXMLSignatureRequestTypeChoice_type0(){ + return localVerifyXMLSignatureRequestTypeChoice_type0; + } + + + + + + + /** + * validate the array for VerifyXMLSignatureRequestTypeChoice_type0 + */ + protected void validateVerifyXMLSignatureRequestTypeChoice_type0(VerifyXMLSignatureRequestTypeChoice_type0[] param){ + + } + + + /** + * Auto generated setter method + * @param param VerifyXMLSignatureRequestTypeChoice_type0 + */ + public void setVerifyXMLSignatureRequestTypeChoice_type0(VerifyXMLSignatureRequestTypeChoice_type0[] param){ + + validateVerifyXMLSignatureRequestTypeChoice_type0(param); + + localVerifyXMLSignatureRequestTypeChoice_type0Tracker = param != null; + + this.localVerifyXMLSignatureRequestTypeChoice_type0=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyXMLSignatureRequestTypeChoice_type0 + */ + public void addVerifyXMLSignatureRequestTypeChoice_type0(VerifyXMLSignatureRequestTypeChoice_type0 param){ + if (localVerifyXMLSignatureRequestTypeChoice_type0 == null){ + localVerifyXMLSignatureRequestTypeChoice_type0 = new VerifyXMLSignatureRequestTypeChoice_type0[]{}; + } + + + //update the setting tracker + localVerifyXMLSignatureRequestTypeChoice_type0Tracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localVerifyXMLSignatureRequestTypeChoice_type0); + list.add(param); + this.localVerifyXMLSignatureRequestTypeChoice_type0 = + (VerifyXMLSignatureRequestTypeChoice_type0[])list.toArray( + new VerifyXMLSignatureRequestTypeChoice_type0[list.size()]); + + } + + + /** + * field for SignatureManifestCheckParams + */ + + + protected SignatureManifestCheckParams_type0 localSignatureManifestCheckParams ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSignatureManifestCheckParamsTracker = false ; + + public boolean isSignatureManifestCheckParamsSpecified(){ + return localSignatureManifestCheckParamsTracker; + } + + + + /** + * Auto generated getter method + * @return SignatureManifestCheckParams_type0 + */ + public SignatureManifestCheckParams_type0 getSignatureManifestCheckParams(){ + return localSignatureManifestCheckParams; + } + + + + /** + * Auto generated setter method + * @param param SignatureManifestCheckParams + */ + public void setSignatureManifestCheckParams(SignatureManifestCheckParams_type0 param){ + localSignatureManifestCheckParamsTracker = param != null; + + this.localSignatureManifestCheckParams=param; + + + } + + + /** + * field for ReturnHashInputData + */ + + + protected org.apache.axiom.om.OMElement localReturnHashInputData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localReturnHashInputDataTracker = false ; + + public boolean isReturnHashInputDataSpecified(){ + return localReturnHashInputDataTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getReturnHashInputData(){ + return localReturnHashInputData; + } + + + + /** + * Auto generated setter method + * @param param ReturnHashInputData + */ + public void setReturnHashInputData(org.apache.axiom.om.OMElement param){ + localReturnHashInputDataTracker = param != null; + + this.localReturnHashInputData=param; + + + } + + + /** + * field for TrustProfileID + */ + + + protected org.apache.axis2.databinding.types.Token localTrustProfileID ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getTrustProfileID(){ + return localTrustProfileID; + } + + + + /** + * Auto generated setter method + * @param param TrustProfileID + */ + public void setTrustProfileID(org.apache.axis2.databinding.types.Token param){ + + this.localTrustProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyXMLSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyXMLSignatureRequestType", + xmlWriter); + } + + + } + if (localDateTimeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "DateTime", xmlWriter); + + + if (localDateTime==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + + } + + xmlWriter.writeEndElement(); + } + if (localVerifySignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureInfo cannot be null!!"); + } + localVerifySignatureInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureInfo"), + xmlWriter); + if (localVerifyXMLSignatureRequestTypeChoice_type0Tracker){ + + if (localVerifyXMLSignatureRequestTypeChoice_type0!=null){ + for (int i = 0;i < localVerifyXMLSignatureRequestTypeChoice_type0.length;i++){ + if (localVerifyXMLSignatureRequestTypeChoice_type0[i] != null){ + localVerifyXMLSignatureRequestTypeChoice_type0[i].serialize(null,xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureRequestTypeChoice_type0 cannot be null!!"); + } + } if (localSignatureManifestCheckParamsTracker){ + if (localSignatureManifestCheckParams==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheckParams cannot be null!!"); + } + localSignatureManifestCheckParams.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheckParams"), + xmlWriter); + } if (localReturnHashInputDataTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "ReturnHashInputData", xmlWriter); + + + if (localReturnHashInputData==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("ReturnHashInputData cannot be null!!"); + + }else{ + + localReturnHashInputData.serialize(xmlWriter); + + } + + xmlWriter.writeEndElement(); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "TrustProfileID", xmlWriter); + + + if (localTrustProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDateTimeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DateTime")); + + if (localDateTime != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + } else { + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifySignatureInfo")); + + + if (localVerifySignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureInfo cannot be null!!"); + } + elementList.add(localVerifySignatureInfo); + if (localVerifyXMLSignatureRequestTypeChoice_type0Tracker){ + if (localVerifyXMLSignatureRequestTypeChoice_type0!=null) { + for (int i = 0;i < localVerifyXMLSignatureRequestTypeChoice_type0.length;i++){ + + if (localVerifyXMLSignatureRequestTypeChoice_type0[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyXMLSignatureRequestTypeChoice_type0")); + elementList.add(localVerifyXMLSignatureRequestTypeChoice_type0[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureRequestTypeChoice_type0 cannot be null!!"); + + } + + } if (localSignatureManifestCheckParamsTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureManifestCheckParams")); + + + if (localSignatureManifestCheckParams==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheckParams cannot be null!!"); + } + elementList.add(localSignatureManifestCheckParams); + } if (localReturnHashInputDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReturnHashInputData")); + + if (localReturnHashInputData != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReturnHashInputData)); + } else { + throw new org.apache.axis2.databinding.ADBException("ReturnHashInputData cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TrustProfileID")); + + if (localTrustProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureRequestType object = + new VerifyXMLSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyXMLSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyXMLSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DateTime").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DateTime" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDateTime( + org.apache.axis2.databinding.utils.ConverterUtil.convertToDateTime(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureInfo").equals(reader.getName())){ + + object.setVerifySignatureInfo(VerifySignatureInfo_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list3.add(VerifyXMLSignatureRequestTypeChoice_type0.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone3 = false; + while(!loopDone3){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone3 = true; + } else { + list3.add(VerifyXMLSignatureRequestTypeChoice_type0.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setVerifyXMLSignatureRequestTypeChoice_type0((VerifyXMLSignatureRequestTypeChoice_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyXMLSignatureRequestTypeChoice_type0.class, + list3)); + + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheckParams").equals(reader.getName())){ + + object.setSignatureManifestCheckParams(SignatureManifestCheckParams_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ReturnHashInputData" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + org.apache.axiom.om.OMFactory fac = org.apache.axiom.om.OMAbstractFactory.getOMFactory(); + org.apache.axiom.om.OMNamespace omNs = fac.createOMNamespace("http://reference.e-government.gv.at/namespace/moa/20020822#", ""); + org.apache.axiom.om.OMElement _valueReturnHashInputData = fac.createOMElement("ReturnHashInputData", omNs); + _valueReturnHashInputData.addChild(fac.createOMText(_valueReturnHashInputData, content)); + object.setReturnHashInputData(_valueReturnHashInputData); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TrustProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"TrustProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setTrustProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DigestValue", + "ns1"); + + + + /** + * field for DigestValue + */ + + + protected DigestValueType localDigestValue ; + + + /** + * Auto generated getter method + * @return DigestValueType + */ + public DigestValueType getDigestValue(){ + return localDigestValue; + } + + + + /** + * Auto generated setter method + * @param param DigestValue + */ + public void setDigestValue(DigestValueType param){ + + this.localDigestValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!"); + } + localDigestValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localDigestValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestValue object = + new DigestValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue").equals(reader.getName())){ + + object.setDigestValue(DigestValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ProfileIdentifierType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "ProfileIdentifierType", + "ns2"); + + + + /** + * field for ProfileIdentifierType + */ + + + protected org.apache.axis2.databinding.types.Token localProfileIdentifierType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getProfileIdentifierType(){ + return localProfileIdentifierType; + } + + + + /** + * Auto generated setter method + * @param param ProfileIdentifierType + */ + public void setProfileIdentifierType(org.apache.axis2.databinding.types.Token param){ + + this.localProfileIdentifierType=param; + + + } + + + public java.lang.String toString(){ + + return localProfileIdentifierType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ProfileIdentifierType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ProfileIdentifierType", + xmlWriter); + } + } + + if (localProfileIdentifierType==null){ + + throw new org.apache.axis2.databinding.ADBException("ProfileIdentifierType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localProfileIdentifierType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localProfileIdentifierType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static ProfileIdentifierType fromString(java.lang.String value, + java.lang.String namespaceURI){ + ProfileIdentifierType returnValue = new ProfileIdentifierType(); + + returnValue.setProfileIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + return returnValue; + } + + public static ProfileIdentifierType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return ProfileIdentifierType.Factory.fromString(content,namespaceUri); + } else { + return ProfileIdentifierType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ProfileIdentifierType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ProfileIdentifierType object = + new ProfileIdentifierType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ProfileIdentifierType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setProfileIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ManifestRefsCheckResultType extends CheckResultType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ManifestRefsCheckResultType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localCode ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localCode=param; + + + } + + + /** + * field for Info0 + * Type of this field is a subtype of its original. + */ + + + protected ManifestRefsCheckResultInfoType localInfo0 ; + + + /** + * Auto generated getter method + * @return ManifestRefsCheckResultInfoType + */ + public ManifestRefsCheckResultInfoType getInfo0(){ + return localInfo0; + } + + + + /** + * Auto generated setter method + * @param param Info0 + */ + public void setInfo0(ManifestRefsCheckResultInfoType param){ + + this.localInfo0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ManifestRefsCheckResultType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ManifestRefsCheckResultType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + + } + + xmlWriter.writeEndElement(); + + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + localInfo0.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info0")); + + + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + elementList.add(localInfo0); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ManifestRefsCheckResultType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ManifestRefsCheckResultType object = + new ManifestRefsCheckResultType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ManifestRefsCheckResultType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ManifestRefsCheckResultType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0").equals(reader.getName())){ + + object.setInfo0(ManifestRefsCheckResultInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "KeyValue", + "ns1"); + + + + /** + * field for KeyValue + */ + + + protected KeyValueType localKeyValue ; + + + /** + * Auto generated getter method + * @return KeyValueType + */ + public KeyValueType getKeyValue(){ + return localKeyValue; + } + + + + /** + * Auto generated setter method + * @param param KeyValue + */ + public void setKeyValue(KeyValueType param){ + + this.localKeyValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("KeyValue cannot be null!"); + } + localKeyValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localKeyValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyValue object = + new KeyValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyValue").equals(reader.getName())){ + + object.setKeyValue(KeyValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Source_type1 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "source_type1", + "ns2"); + + + + /** + * field for Source_type1 + */ + + + protected org.apache.axis2.databinding.types.Token localSource_type1 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Source_type1(org.apache.axis2.databinding.types.Token value, boolean isRegisterValue) { + localSource_type1 = value; + if (isRegisterValue){ + + _table_.put(localSource_type1, this); + + } + + } + + public static final org.apache.axis2.databinding.types.Token _TSL = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("TSL"); + + public static final org.apache.axis2.databinding.types.Token _Certificate = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("Certificate"); + + public static final Source_type1 TSL = + new Source_type1(_TSL,true); + + public static final Source_type1 Certificate = + new Source_type1(_Certificate,true); + + + public org.apache.axis2.databinding.types.Token getValue() { return localSource_type1;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localSource_type1.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":source_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "source_type1", + xmlWriter); + } + } + + if (localSource_type1==null){ + + throw new org.apache.axis2.databinding.ADBException("source_type1 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type1)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type1) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Source_type1 fromValue(org.apache.axis2.databinding.types.Token value) + throws java.lang.IllegalArgumentException { + Source_type1 enumeration = (Source_type1) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Source_type1 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Source_type1 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Source_type1.Factory.fromString(content,namespaceUri); + } else { + return Source_type1.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Source_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Source_type1 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"source_type1" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Source_type1.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Source_type1.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Source_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "source_type0", + "ns2"); + + + + /** + * field for Source_type0 + */ + + + protected org.apache.axis2.databinding.types.Token localSource_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Source_type0(org.apache.axis2.databinding.types.Token value, boolean isRegisterValue) { + localSource_type0 = value; + if (isRegisterValue){ + + _table_.put(localSource_type0, this); + + } + + } + + public static final org.apache.axis2.databinding.types.Token _TSL = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("TSL"); + + public static final org.apache.axis2.databinding.types.Token _Certificate = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("Certificate"); + + public static final Source_type0 TSL = + new Source_type0(_TSL,true); + + public static final Source_type0 Certificate = + new Source_type0(_Certificate,true); + + + public org.apache.axis2.databinding.types.Token getValue() { return localSource_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localSource_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":source_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "source_type0", + xmlWriter); + } + } + + if (localSource_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("source_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type0)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Source_type0 fromValue(org.apache.axis2.databinding.types.Token value) + throws java.lang.IllegalArgumentException { + Source_type0 enumeration = (Source_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Source_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Source_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Source_type0.Factory.fromString(content,namespaceUri); + } else { + return Source_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Source_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Source_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"source_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Source_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Source_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyXMLSignatureResponse", + "ns2"); + + + + /** + * field for VerifyXMLSignatureResponse + */ + + + protected VerifyXMLSignatureResponseType localVerifyXMLSignatureResponse ; + + + /** + * Auto generated getter method + * @return VerifyXMLSignatureResponseType + */ + public VerifyXMLSignatureResponseType getVerifyXMLSignatureResponse(){ + return localVerifyXMLSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param VerifyXMLSignatureResponse + */ + public void setVerifyXMLSignatureResponse(VerifyXMLSignatureResponseType param){ + + this.localVerifyXMLSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyXMLSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureResponse cannot be null!"); + } + localVerifyXMLSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyXMLSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureResponse object = + new VerifyXMLSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyXMLSignatureResponse").equals(reader.getName())){ + + object.setVerifyXMLSignatureResponse(VerifyXMLSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CheckResultType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CheckResultType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localCode ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localCode=param; + + + } + + + /** + * field for Info + */ + + + protected AnyChildrenType localInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localInfoTracker = false ; + + public boolean isInfoSpecified(){ + return localInfoTracker; + } + + + + /** + * Auto generated getter method + * @return AnyChildrenType + */ + public AnyChildrenType getInfo(){ + return localInfo; + } + + + + /** + * Auto generated setter method + * @param param Info + */ + public void setInfo(AnyChildrenType param){ + localInfoTracker = param != null; + + this.localInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CheckResultType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CheckResultType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + + } + + xmlWriter.writeEndElement(); + if (localInfoTracker){ + if (localInfo==null){ + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + } + localInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + if (localInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info")); + + + if (localInfo==null){ + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + } + elementList.add(localInfo); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CheckResultType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CheckResultType object = + new CheckResultType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CheckResultType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CheckResultType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info").equals(reader.getName())){ + + object.setInfo(AnyChildrenType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ObjectType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ObjectType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ObjectTypeSequence + * This was an Array! + */ + + + protected ObjectTypeSequence[] localObjectTypeSequence ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localObjectTypeSequenceTracker = false ; + + public boolean isObjectTypeSequenceSpecified(){ + return localObjectTypeSequenceTracker; + } + + + + /** + * Auto generated getter method + * @return ObjectTypeSequence[] + */ + public ObjectTypeSequence[] getObjectTypeSequence(){ + return localObjectTypeSequence; + } + + + + + + + /** + * validate the array for ObjectTypeSequence + */ + protected void validateObjectTypeSequence(ObjectTypeSequence[] param){ + + } + + + /** + * Auto generated setter method + * @param param ObjectTypeSequence + */ + public void setObjectTypeSequence(ObjectTypeSequence[] param){ + + validateObjectTypeSequence(param); + + localObjectTypeSequenceTracker = param != null; + + this.localObjectTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ObjectTypeSequence + */ + public void addObjectTypeSequence(ObjectTypeSequence param){ + if (localObjectTypeSequence == null){ + localObjectTypeSequence = new ObjectTypeSequence[]{}; + } + + + //update the setting tracker + localObjectTypeSequenceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localObjectTypeSequence); + list.add(param); + this.localObjectTypeSequence = + (ObjectTypeSequence[])list.toArray( + new ObjectTypeSequence[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + /** + * field for MimeType + * This was an Attribute! + */ + + + protected java.lang.String localMimeType ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getMimeType(){ + return localMimeType; + } + + + + /** + * Auto generated setter method + * @param param MimeType + */ + public void setMimeType(java.lang.String param){ + + this.localMimeType=param; + + + } + + + /** + * field for Encoding + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localEncoding ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getEncoding(){ + return localEncoding; + } + + + + /** + * Auto generated setter method + * @param param Encoding + */ + public void setEncoding(org.apache.axis2.databinding.types.URI param){ + + this.localEncoding=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ObjectType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ObjectType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localMimeType != null){ + + writeAttribute("", + "MimeType", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeType), xmlWriter); + + + } + + if (localEncoding != null){ + + writeAttribute("", + "Encoding", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEncoding), xmlWriter); + + + } + if (localObjectTypeSequenceTracker){ + + if (localObjectTypeSequence!=null){ + for (int i = 0;i < localObjectTypeSequence.length;i++){ + if (localObjectTypeSequence[i] != null){ + localObjectTypeSequence[i].serialize(null,xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("ObjectTypeSequence cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localObjectTypeSequenceTracker){ + if (localObjectTypeSequence!=null) { + for (int i = 0;i < localObjectTypeSequence.length;i++){ + + if (localObjectTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "ObjectTypeSequence")); + elementList.add(localObjectTypeSequence[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ObjectTypeSequence cannot be null!!"); + + } + + } + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + attribList.add( + new javax.xml.namespace.QName("","MimeType")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeType)); + + attribList.add( + new javax.xml.namespace.QName("","Encoding")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEncoding)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ObjectType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ObjectType object = + new ObjectType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ObjectType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ObjectType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + // handle attribute "MimeType" + java.lang.String tempAttribMimeType = + + reader.getAttributeValue(null,"MimeType"); + + if (tempAttribMimeType!=null){ + java.lang.String content = tempAttribMimeType; + + object.setMimeType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(tempAttribMimeType)); + + } else { + + } + handledAttributes.add("MimeType"); + + // handle attribute "Encoding" + java.lang.String tempAttribEncoding = + + reader.getAttributeValue(null,"Encoding"); + + if (tempAttribEncoding!=null){ + java.lang.String content = tempAttribEncoding; + + object.setEncoding( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribEncoding)); + + } else { + + } + handledAttributes.add("Encoding"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(ObjectTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(ObjectTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setObjectTypeSequence((ObjectTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ObjectTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Supplement + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "Supplement", + "ns2"); + + + + /** + * field for Supplement + */ + + + protected XMLDataObjectAssociationType localSupplement ; + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType + */ + public XMLDataObjectAssociationType getSupplement(){ + return localSupplement; + } + + + + /** + * Auto generated setter method + * @param param Supplement + */ + public void setSupplement(XMLDataObjectAssociationType param){ + + this.localSupplement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSupplement==null){ + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!"); + } + localSupplement.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSupplement.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Supplement parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Supplement object = + new Supplement(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + + object.setSupplement(XMLDataObjectAssociationType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + + private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest param, boolean optimizeContent, javax.xml.namespace.QName methodQName) + throws org.apache.axis2.AxisFault{ + + + try{ + + org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope(); + emptyEnvelope.getBody().addChild(param.getOMElement(at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest.MY_QNAME,factory)); + return emptyEnvelope; + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + + /* methods to provide back word compatibility */ + + + + private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest param, boolean optimizeContent, javax.xml.namespace.QName methodQName) + throws org.apache.axis2.AxisFault{ + + + try{ + + org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope(); + emptyEnvelope.getBody().addChild(param.getOMElement(at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest.MY_QNAME,factory)); + return emptyEnvelope; + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + + /* methods to provide back word compatibility */ + + + + + /** + * get the default envelope + */ + private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){ + return factory.getDefaultEnvelope(); + } + + + private java.lang.Object fromOM( + org.apache.axiom.om.OMElement param, + java.lang.Class type, + java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{ + + try { + + if (at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest.class.equals(type)){ + + return at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureCreationServiceStub.CreateXMLSignatureResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest.class.equals(type)){ + + return at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureCreationServiceStub.CreateCMSSignatureResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureCreationServiceStub.ErrorResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + } catch (java.lang.Exception e) { + throw org.apache.axis2.AxisFault.makeFault(e); + } + return null; + } + + + + + } + \ No newline at end of file diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceCallbackHandler.java b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceCallbackHandler.java new file mode 100644 index 00000000..25d1424c --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceCallbackHandler.java @@ -0,0 +1,82 @@ + +/** + * SignatureVerificationServiceCallbackHandler.java + * + * This file was auto-generated from WSDL + * by the Apache Axis2 version: 1.6.2 Built on : Apr 17, 2012 (05:33:49 IST) + */ + + package at.gv.egiz.moa; + + /** + * SignatureVerificationServiceCallbackHandler Callback class, Users can extend this class and implement + * their own receiveResult and receiveError methods. + */ + public abstract class SignatureVerificationServiceCallbackHandler{ + + + + protected Object clientData; + + /** + * User can pass in any object that needs to be accessed once the NonBlocking + * Web service call is finished and appropriate method of this CallBack is called. + * @param clientData Object mechanism by which the user can pass in user data + * that will be avilable at the time this callback is called. + */ + public SignatureVerificationServiceCallbackHandler(Object clientData){ + this.clientData = clientData; + } + + /** + * Please use this constructor if you don't want to set any clientData + */ + public SignatureVerificationServiceCallbackHandler(){ + this.clientData = null; + } + + /** + * Get the client data + */ + + public Object getClientData() { + return clientData; + } + + + /** + * auto generated Axis2 call back method for verifyXMLSignature method + * override this method for handling normal response from verifyXMLSignature operation + */ + public void receiveResultverifyXMLSignature( + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse result + ) { + } + + /** + * auto generated Axis2 Error handler + * override this method for handling error response from verifyXMLSignature operation + */ + public void receiveErrorverifyXMLSignature(java.lang.Exception e) { + } + + /** + * auto generated Axis2 call back method for verifyCMSSignature method + * override this method for handling normal response from verifyCMSSignature operation + */ + public void receiveResultverifyCMSSignature( + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse result + ) { + } + + /** + * auto generated Axis2 Error handler + * override this method for handling error response from verifyCMSSignature operation + */ + public void receiveErrorverifyCMSSignature(java.lang.Exception e) { + } + + + + } + \ No newline at end of file diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceStub.java b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceStub.java new file mode 100644 index 00000000..133d04db --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/moa/SignatureVerificationServiceStub.java @@ -0,0 +1,71259 @@ + +/** + * SignatureVerificationServiceStub.java + * + * This file was auto-generated from WSDL + * by the Apache Axis2 version: 1.6.2 Built on : Apr 17, 2012 (05:33:49 IST) + */ + package at.gv.egiz.moa; + + + + /* + * SignatureVerificationServiceStub java implementation + */ + + + public class SignatureVerificationServiceStub extends org.apache.axis2.client.Stub + { + protected org.apache.axis2.description.AxisOperation[] _operations; + + //hashmaps to keep the fault mapping + private java.util.HashMap faultExceptionNameMap = new java.util.HashMap(); + private java.util.HashMap faultExceptionClassNameMap = new java.util.HashMap(); + private java.util.HashMap faultMessageMap = new java.util.HashMap(); + + private static int counter = 0; + + private static synchronized java.lang.String getUniqueSuffix(){ + // reset the counter if it is greater than 99999 + if (counter > 99999){ + counter = 0; + } + counter = counter + 1; + return java.lang.Long.toString(java.lang.System.currentTimeMillis()) + "_" + counter; + } + + + private void populateAxisService() throws org.apache.axis2.AxisFault { + + //creating the Service with a unique name + _service = new org.apache.axis2.description.AxisService("SignatureVerificationService" + getUniqueSuffix()); + addAnonymousOperations(); + + //creating the operations + org.apache.axis2.description.AxisOperation __operation; + + _operations = new org.apache.axis2.description.AxisOperation[2]; + + __operation = new org.apache.axis2.description.OutInAxisOperation(); + + + __operation.setName(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", "verifyXMLSignature")); + _service.addOperation(__operation); + + + + + _operations[0]=__operation; + + + __operation = new org.apache.axis2.description.OutInAxisOperation(); + + + __operation.setName(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", "verifyCMSSignature")); + _service.addOperation(__operation); + + + + + _operations[1]=__operation; + + + } + + //populates the faults + private void populateFaults(){ + + faultExceptionNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "verifyXMLSignature"),"at.gv.egiz.moa.MOAFault"); + faultExceptionClassNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "verifyXMLSignature"),"at.gv.egiz.moa.MOAFault"); + faultMessageMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "verifyXMLSignature"),"at.gv.egiz.moa.SignatureVerificationServiceStub$ErrorResponse"); + + faultExceptionNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "verifyCMSSignature"),"at.gv.egiz.moa.MOAFault"); + faultExceptionClassNameMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "verifyCMSSignature"),"at.gv.egiz.moa.MOAFault"); + faultMessageMap.put(new org.apache.axis2.client.FaultMapKey(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), "verifyCMSSignature"),"at.gv.egiz.moa.SignatureVerificationServiceStub$ErrorResponse"); + + + + } + + /** + *Constructor that takes in a configContext + */ + + public SignatureVerificationServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext, + java.lang.String targetEndpoint) + throws org.apache.axis2.AxisFault { + this(configurationContext,targetEndpoint,false); + } + + + /** + * Constructor that takes in a configContext and useseperate listner + */ + public SignatureVerificationServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext, + java.lang.String targetEndpoint, boolean useSeparateListener) + throws org.apache.axis2.AxisFault { + //To populate AxisService + populateAxisService(); + populateFaults(); + + _serviceClient = new org.apache.axis2.client.ServiceClient(configurationContext,_service); + + + _serviceClient.getOptions().setTo(new org.apache.axis2.addressing.EndpointReference( + targetEndpoint)); + _serviceClient.getOptions().setUseSeparateListener(useSeparateListener); + + + } + + /** + * Default Constructor + */ + public SignatureVerificationServiceStub(org.apache.axis2.context.ConfigurationContext configurationContext) throws org.apache.axis2.AxisFault { + + this(configurationContext,"" ); + + } + + /** + * Default Constructor + */ + public SignatureVerificationServiceStub() throws org.apache.axis2.AxisFault { + + this("" ); + + } + + /** + * Constructor taking the target endpoint + */ + public SignatureVerificationServiceStub(java.lang.String targetEndpoint) throws org.apache.axis2.AxisFault { + this(null,targetEndpoint); + } + + + + + /** + * Auto generated method signature + * + * @see at.gv.egiz.moa.SignatureVerificationService#verifyXMLSignature + * @param verifyXMLSignatureRequest8 + + * @throws at.gv.egiz.moa.MOAFault : + */ + + + + public at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse verifyXMLSignature( + + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest verifyXMLSignatureRequest8) + + + throws java.rmi.RemoteException + + + ,at.gv.egiz.moa.MOAFault{ + org.apache.axis2.context.MessageContext _messageContext = null; + try{ + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName()); + _operationClient.getOptions().setAction("urn:VerifyXMLSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + // create a message context + _messageContext = new org.apache.axis2.context.MessageContext(); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env = null; + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + verifyXMLSignatureRequest8, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyXMLSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyXMLSignature")); + + //adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // set the message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message contxt to the operation client + _operationClient.addMessageContext(_messageContext); + + //execute the operation client + _operationClient.execute(true); + + + org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext( + org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE); + org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope(); + + + java.lang.Object object = fromOM( + _returnEnv.getBody().getFirstElement() , + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse.class, + getEnvelopeNamespaces(_returnEnv)); + + + return (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse)object; + + }catch(org.apache.axis2.AxisFault f){ + + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyXMLSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyXMLSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyXMLSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + throw (at.gv.egiz.moa.MOAFault)ex; + } + + + throw new java.rmi.RemoteException(ex.getMessage(), ex); + }catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + }catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } + }else{ + throw f; + } + }else{ + throw f; + } + } finally { + if (_messageContext.getTransportOut() != null) { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } + } + } + + /** + * Auto generated method signature for Asynchronous Invocations + * + * @see at.gv.egiz.moa.SignatureVerificationService#startverifyXMLSignature + * @param verifyXMLSignatureRequest8 + + */ + public void startverifyXMLSignature( + + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest verifyXMLSignatureRequest8, + + final at.gv.egiz.moa.SignatureVerificationServiceCallbackHandler callback) + + throws java.rmi.RemoteException{ + + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[0].getName()); + _operationClient.getOptions().setAction("urn:VerifyXMLSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env=null; + final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext(); + + + //Style is Doc. + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + verifyXMLSignatureRequest8, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyXMLSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyXMLSignature")); + + // adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // create message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message context to the operation client + _operationClient.addMessageContext(_messageContext); + + + + _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() { + public void onMessage(org.apache.axis2.context.MessageContext resultContext) { + try { + org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope(); + + java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(), + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse.class, + getEnvelopeNamespaces(resultEnv)); + callback.receiveResultverifyXMLSignature( + (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse)object); + + } catch (org.apache.axis2.AxisFault e) { + callback.receiveErrorverifyXMLSignature(e); + } + } + + public void onError(java.lang.Exception error) { + if (error instanceof org.apache.axis2.AxisFault) { + org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error; + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyXMLSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyXMLSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyXMLSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + callback.receiveErrorverifyXMLSignature((at.gv.egiz.moa.MOAFault)ex); + return; + } + + + callback.receiveErrorverifyXMLSignature(new java.rmi.RemoteException(ex.getMessage(), ex)); + } catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyXMLSignature(f); + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyXMLSignature(f); + } catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyXMLSignature(f); + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyXMLSignature(f); + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyXMLSignature(f); + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyXMLSignature(f); + } catch (org.apache.axis2.AxisFault e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyXMLSignature(f); + } + } else { + callback.receiveErrorverifyXMLSignature(f); + } + } else { + callback.receiveErrorverifyXMLSignature(f); + } + } else { + callback.receiveErrorverifyXMLSignature(error); + } + } + + public void onFault(org.apache.axis2.context.MessageContext faultContext) { + org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext); + onError(fault); + } + + public void onComplete() { + try { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } catch (org.apache.axis2.AxisFault axisFault) { + callback.receiveErrorverifyXMLSignature(axisFault); + } + } + }); + + + org.apache.axis2.util.CallbackReceiver _callbackReceiver = null; + if ( _operations[0].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) { + _callbackReceiver = new org.apache.axis2.util.CallbackReceiver(); + _operations[0].setMessageReceiver( + _callbackReceiver); + } + + //execute the operation client + _operationClient.execute(false); + + } + + /** + * Auto generated method signature + * + * @see at.gv.egiz.moa.SignatureVerificationService#verifyCMSSignature + * @param verifyCMSSignatureRequest10 + + * @throws at.gv.egiz.moa.MOAFault : + */ + + + + public at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse verifyCMSSignature( + + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest verifyCMSSignatureRequest10) + + + throws java.rmi.RemoteException + + + ,at.gv.egiz.moa.MOAFault{ + org.apache.axis2.context.MessageContext _messageContext = null; + try{ + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName()); + _operationClient.getOptions().setAction("urn:VerifyCMSSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + // create a message context + _messageContext = new org.apache.axis2.context.MessageContext(); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env = null; + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + verifyCMSSignatureRequest10, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyCMSSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyCMSSignature")); + + //adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // set the message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message contxt to the operation client + _operationClient.addMessageContext(_messageContext); + + //execute the operation client + _operationClient.execute(true); + + + org.apache.axis2.context.MessageContext _returnMessageContext = _operationClient.getMessageContext( + org.apache.axis2.wsdl.WSDLConstants.MESSAGE_LABEL_IN_VALUE); + org.apache.axiom.soap.SOAPEnvelope _returnEnv = _returnMessageContext.getEnvelope(); + + + java.lang.Object object = fromOM( + _returnEnv.getBody().getFirstElement() , + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse.class, + getEnvelopeNamespaces(_returnEnv)); + + + return (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse)object; + + }catch(org.apache.axis2.AxisFault f){ + + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyCMSSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyCMSSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyCMSSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + throw (at.gv.egiz.moa.MOAFault)ex; + } + + + throw new java.rmi.RemoteException(ex.getMessage(), ex); + }catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + }catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + throw f; + } + }else{ + throw f; + } + }else{ + throw f; + } + } finally { + if (_messageContext.getTransportOut() != null) { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } + } + } + + /** + * Auto generated method signature for Asynchronous Invocations + * + * @see at.gv.egiz.moa.SignatureVerificationService#startverifyCMSSignature + * @param verifyCMSSignatureRequest10 + + */ + public void startverifyCMSSignature( + + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest verifyCMSSignatureRequest10, + + final at.gv.egiz.moa.SignatureVerificationServiceCallbackHandler callback) + + throws java.rmi.RemoteException{ + + org.apache.axis2.client.OperationClient _operationClient = _serviceClient.createClient(_operations[1].getName()); + _operationClient.getOptions().setAction("urn:VerifyCMSSignatureAction"); + _operationClient.getOptions().setExceptionToBeThrownOnSOAPFault(true); + + + + addPropertyToOperationClient(_operationClient,org.apache.axis2.description.WSDL2Constants.ATTR_WHTTP_QUERY_PARAMETER_SEPARATOR,"&"); + + + + // create SOAP envelope with that payload + org.apache.axiom.soap.SOAPEnvelope env=null; + final org.apache.axis2.context.MessageContext _messageContext = new org.apache.axis2.context.MessageContext(); + + + //Style is Doc. + + + env = toEnvelope(getFactory(_operationClient.getOptions().getSoapVersionURI()), + verifyCMSSignatureRequest10, + optimizeContent(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyCMSSignature")), new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "verifyCMSSignature")); + + // adding SOAP soap_headers + _serviceClient.addHeadersToEnvelope(env); + // create message context with that soap envelope + _messageContext.setEnvelope(env); + + // add the message context to the operation client + _operationClient.addMessageContext(_messageContext); + + + + _operationClient.setCallback(new org.apache.axis2.client.async.AxisCallback() { + public void onMessage(org.apache.axis2.context.MessageContext resultContext) { + try { + org.apache.axiom.soap.SOAPEnvelope resultEnv = resultContext.getEnvelope(); + + java.lang.Object object = fromOM(resultEnv.getBody().getFirstElement(), + at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse.class, + getEnvelopeNamespaces(resultEnv)); + callback.receiveResultverifyCMSSignature( + (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse)object); + + } catch (org.apache.axis2.AxisFault e) { + callback.receiveErrorverifyCMSSignature(e); + } + } + + public void onError(java.lang.Exception error) { + if (error instanceof org.apache.axis2.AxisFault) { + org.apache.axis2.AxisFault f = (org.apache.axis2.AxisFault) error; + org.apache.axiom.om.OMElement faultElt = f.getDetail(); + if (faultElt!=null){ + if (faultExceptionNameMap.containsKey(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyCMSSignature"))){ + //make the fault by reflection + try{ + java.lang.String exceptionClassName = (java.lang.String)faultExceptionClassNameMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyCMSSignature")); + java.lang.Class exceptionClass = java.lang.Class.forName(exceptionClassName); + java.lang.reflect.Constructor constructor = exceptionClass.getConstructor(String.class); + java.lang.Exception ex = (java.lang.Exception) constructor.newInstance(f.getMessage()); + //message class + java.lang.String messageClassName = (java.lang.String)faultMessageMap.get(new org.apache.axis2.client.FaultMapKey(faultElt.getQName(),"verifyCMSSignature")); + java.lang.Class messageClass = java.lang.Class.forName(messageClassName); + java.lang.Object messageObject = fromOM(faultElt,messageClass,null); + java.lang.reflect.Method m = exceptionClass.getMethod("setFaultMessage", + new java.lang.Class[]{messageClass}); + m.invoke(ex,new java.lang.Object[]{messageObject}); + + if (ex instanceof at.gv.egiz.moa.MOAFault){ + callback.receiveErrorverifyCMSSignature((at.gv.egiz.moa.MOAFault)ex); + return; + } + + + callback.receiveErrorverifyCMSSignature(new java.rmi.RemoteException(ex.getMessage(), ex)); + } catch(java.lang.ClassCastException e){ + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyCMSSignature(f); + } catch (java.lang.ClassNotFoundException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyCMSSignature(f); + } catch (java.lang.NoSuchMethodException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyCMSSignature(f); + } catch (java.lang.reflect.InvocationTargetException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyCMSSignature(f); + } catch (java.lang.IllegalAccessException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyCMSSignature(f); + } catch (java.lang.InstantiationException e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyCMSSignature(f); + } catch (org.apache.axis2.AxisFault e) { + // we cannot intantiate the class - throw the original Axis fault + callback.receiveErrorverifyCMSSignature(f); + } + } else { + callback.receiveErrorverifyCMSSignature(f); + } + } else { + callback.receiveErrorverifyCMSSignature(f); + } + } else { + callback.receiveErrorverifyCMSSignature(error); + } + } + + public void onFault(org.apache.axis2.context.MessageContext faultContext) { + org.apache.axis2.AxisFault fault = org.apache.axis2.util.Utils.getInboundFaultFromMessageContext(faultContext); + onError(fault); + } + + public void onComplete() { + try { + _messageContext.getTransportOut().getSender().cleanup(_messageContext); + } catch (org.apache.axis2.AxisFault axisFault) { + callback.receiveErrorverifyCMSSignature(axisFault); + } + } + }); + + + org.apache.axis2.util.CallbackReceiver _callbackReceiver = null; + if ( _operations[1].getMessageReceiver()==null && _operationClient.getOptions().isUseSeparateListener()) { + _callbackReceiver = new org.apache.axis2.util.CallbackReceiver(); + _operations[1].setMessageReceiver( + _callbackReceiver); + } + + //execute the operation client + _operationClient.execute(false); + + } + + + + /** + * A utility method that copies the namepaces from the SOAPEnvelope + */ + private java.util.Map getEnvelopeNamespaces(org.apache.axiom.soap.SOAPEnvelope env){ + java.util.Map returnMap = new java.util.HashMap(); + java.util.Iterator namespaceIterator = env.getAllDeclaredNamespaces(); + while (namespaceIterator.hasNext()) { + org.apache.axiom.om.OMNamespace ns = (org.apache.axiom.om.OMNamespace) namespaceIterator.next(); + returnMap.put(ns.getPrefix(),ns.getNamespaceURI()); + } + return returnMap; + } + + + + private javax.xml.namespace.QName[] opNameArray = null; + private boolean optimizeContent(javax.xml.namespace.QName opName) { + + + if (opNameArray == null) { + return false; + } + for (int i = 0; i < opNameArray.length; i++) { + if (opName.equals(opNameArray[i])) { + return true; + } + } + return false; + } + // + public static class PGPData + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "PGPData", + "ns1"); + + + + /** + * field for PGPData + */ + + + protected PGPDataType localPGPData ; + + + /** + * Auto generated getter method + * @return PGPDataType + */ + public PGPDataType getPGPData(){ + return localPGPData; + } + + + + /** + * Auto generated setter method + * @param param PGPData + */ + public void setPGPData(PGPDataType param){ + + this.localPGPData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localPGPData==null){ + throw new org.apache.axis2.databinding.ADBException("PGPData cannot be null!"); + } + localPGPData.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localPGPData.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPData parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPData object = + new PGPData(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPData").equals(reader.getName())){ + + object.setPGPData(PGPDataType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentOptionalRefType extends ContentBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentOptionalRefType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Reference + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localReference ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getReference(){ + return localReference; + } + + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(org.apache.axis2.databinding.types.URI param){ + + this.localReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentOptionalRefType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentOptionalRefType", + xmlWriter); + } + + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ContentOptionalRefType")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentOptionalRefType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentOptionalRefType object = + new ContentOptionalRefType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentOptionalRefType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentOptionalRefType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyXMLSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for SignerInfo + */ + + + protected KeyInfoType localSignerInfo ; + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getSignerInfo(){ + return localSignerInfo; + } + + + + /** + * Auto generated setter method + * @param param SignerInfo + */ + public void setSignerInfo(KeyInfoType param){ + + this.localSignerInfo=param; + + + } + + + /** + * field for HashInputData + * This was an Array! + */ + + + protected InputDataType[] localHashInputData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localHashInputDataTracker = false ; + + public boolean isHashInputDataSpecified(){ + return localHashInputDataTracker; + } + + + + /** + * Auto generated getter method + * @return InputDataType[] + */ + public InputDataType[] getHashInputData(){ + return localHashInputData; + } + + + + + + + /** + * validate the array for HashInputData + */ + protected void validateHashInputData(InputDataType[] param){ + + } + + + /** + * Auto generated setter method + * @param param HashInputData + */ + public void setHashInputData(InputDataType[] param){ + + validateHashInputData(param); + + localHashInputDataTracker = param != null; + + this.localHashInputData=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param InputDataType + */ + public void addHashInputData(InputDataType param){ + if (localHashInputData == null){ + localHashInputData = new InputDataType[]{}; + } + + + //update the setting tracker + localHashInputDataTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localHashInputData); + list.add(param); + this.localHashInputData = + (InputDataType[])list.toArray( + new InputDataType[list.size()]); + + } + + + /** + * field for ReferenceInputData + * This was an Array! + */ + + + protected InputDataType[] localReferenceInputData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localReferenceInputDataTracker = false ; + + public boolean isReferenceInputDataSpecified(){ + return localReferenceInputDataTracker; + } + + + + /** + * Auto generated getter method + * @return InputDataType[] + */ + public InputDataType[] getReferenceInputData(){ + return localReferenceInputData; + } + + + + + + + /** + * validate the array for ReferenceInputData + */ + protected void validateReferenceInputData(InputDataType[] param){ + + } + + + /** + * Auto generated setter method + * @param param ReferenceInputData + */ + public void setReferenceInputData(InputDataType[] param){ + + validateReferenceInputData(param); + + localReferenceInputDataTracker = param != null; + + this.localReferenceInputData=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param InputDataType + */ + public void addReferenceInputData(InputDataType param){ + if (localReferenceInputData == null){ + localReferenceInputData = new InputDataType[]{}; + } + + + //update the setting tracker + localReferenceInputDataTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReferenceInputData); + list.add(param); + this.localReferenceInputData = + (InputDataType[])list.toArray( + new InputDataType[list.size()]); + + } + + + /** + * field for SignatureCheck + */ + + + protected ReferencesCheckResultType localSignatureCheck ; + + + /** + * Auto generated getter method + * @return ReferencesCheckResultType + */ + public ReferencesCheckResultType getSignatureCheck(){ + return localSignatureCheck; + } + + + + /** + * Auto generated setter method + * @param param SignatureCheck + */ + public void setSignatureCheck(ReferencesCheckResultType param){ + + this.localSignatureCheck=param; + + + } + + + /** + * field for SignatureManifestCheck + */ + + + protected ReferencesCheckResultType localSignatureManifestCheck ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSignatureManifestCheckTracker = false ; + + public boolean isSignatureManifestCheckSpecified(){ + return localSignatureManifestCheckTracker; + } + + + + /** + * Auto generated getter method + * @return ReferencesCheckResultType + */ + public ReferencesCheckResultType getSignatureManifestCheck(){ + return localSignatureManifestCheck; + } + + + + /** + * Auto generated setter method + * @param param SignatureManifestCheck + */ + public void setSignatureManifestCheck(ReferencesCheckResultType param){ + localSignatureManifestCheckTracker = param != null; + + this.localSignatureManifestCheck=param; + + + } + + + /** + * field for XMLDSIGManifestCheck + * This was an Array! + */ + + + protected ManifestRefsCheckResultType[] localXMLDSIGManifestCheck ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLDSIGManifestCheckTracker = false ; + + public boolean isXMLDSIGManifestCheckSpecified(){ + return localXMLDSIGManifestCheckTracker; + } + + + + /** + * Auto generated getter method + * @return ManifestRefsCheckResultType[] + */ + public ManifestRefsCheckResultType[] getXMLDSIGManifestCheck(){ + return localXMLDSIGManifestCheck; + } + + + + + + + /** + * validate the array for XMLDSIGManifestCheck + */ + protected void validateXMLDSIGManifestCheck(ManifestRefsCheckResultType[] param){ + + } + + + /** + * Auto generated setter method + * @param param XMLDSIGManifestCheck + */ + public void setXMLDSIGManifestCheck(ManifestRefsCheckResultType[] param){ + + validateXMLDSIGManifestCheck(param); + + localXMLDSIGManifestCheckTracker = param != null; + + this.localXMLDSIGManifestCheck=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ManifestRefsCheckResultType + */ + public void addXMLDSIGManifestCheck(ManifestRefsCheckResultType param){ + if (localXMLDSIGManifestCheck == null){ + localXMLDSIGManifestCheck = new ManifestRefsCheckResultType[]{}; + } + + + //update the setting tracker + localXMLDSIGManifestCheckTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localXMLDSIGManifestCheck); + list.add(param); + this.localXMLDSIGManifestCheck = + (ManifestRefsCheckResultType[])list.toArray( + new ManifestRefsCheckResultType[list.size()]); + + } + + + /** + * field for CertificateCheck + */ + + + protected CheckResultType localCertificateCheck ; + + + /** + * Auto generated getter method + * @return CheckResultType + */ + public CheckResultType getCertificateCheck(){ + return localCertificateCheck; + } + + + + /** + * Auto generated setter method + * @param param CertificateCheck + */ + public void setCertificateCheck(CheckResultType param){ + + this.localCertificateCheck=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyXMLSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyXMLSignatureResponseType", + xmlWriter); + } + + + } + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + localSignerInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo"), + xmlWriter); + if (localHashInputDataTracker){ + if (localHashInputData!=null){ + for (int i = 0;i < localHashInputData.length;i++){ + if (localHashInputData[i] != null){ + localHashInputData[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","HashInputData"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("HashInputData cannot be null!!"); + + } + } if (localReferenceInputDataTracker){ + if (localReferenceInputData!=null){ + for (int i = 0;i < localReferenceInputData.length;i++){ + if (localReferenceInputData[i] != null){ + localReferenceInputData[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInputData"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInputData cannot be null!!"); + + } + } + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + localSignatureCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck"), + xmlWriter); + if (localSignatureManifestCheckTracker){ + if (localSignatureManifestCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheck cannot be null!!"); + } + localSignatureManifestCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheck"), + xmlWriter); + } if (localXMLDSIGManifestCheckTracker){ + if (localXMLDSIGManifestCheck!=null){ + for (int i = 0;i < localXMLDSIGManifestCheck.length;i++){ + if (localXMLDSIGManifestCheck[i] != null){ + localXMLDSIGManifestCheck[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLDSIGManifestCheck"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("XMLDSIGManifestCheck cannot be null!!"); + + } + } + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + localCertificateCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignerInfo")); + + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + elementList.add(localSignerInfo); + if (localHashInputDataTracker){ + if (localHashInputData!=null) { + for (int i = 0;i < localHashInputData.length;i++){ + + if (localHashInputData[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "HashInputData")); + elementList.add(localHashInputData[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("HashInputData cannot be null!!"); + + } + + } if (localReferenceInputDataTracker){ + if (localReferenceInputData!=null) { + for (int i = 0;i < localReferenceInputData.length;i++){ + + if (localReferenceInputData[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReferenceInputData")); + elementList.add(localReferenceInputData[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInputData cannot be null!!"); + + } + + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureCheck")); + + + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + elementList.add(localSignatureCheck); + if (localSignatureManifestCheckTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureManifestCheck")); + + + if (localSignatureManifestCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheck cannot be null!!"); + } + elementList.add(localSignatureManifestCheck); + } if (localXMLDSIGManifestCheckTracker){ + if (localXMLDSIGManifestCheck!=null) { + for (int i = 0;i < localXMLDSIGManifestCheck.length;i++){ + + if (localXMLDSIGManifestCheck[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLDSIGManifestCheck")); + elementList.add(localXMLDSIGManifestCheck[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("XMLDSIGManifestCheck cannot be null!!"); + + } + + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CertificateCheck")); + + + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + elementList.add(localCertificateCheck); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureResponseType object = + new VerifyXMLSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyXMLSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyXMLSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + java.util.ArrayList list6 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo").equals(reader.getName())){ + + object.setSignerInfo(KeyInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","HashInputData").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(InputDataType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","HashInputData").equals(reader.getName())){ + list2.add(InputDataType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setHashInputData((InputDataType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + InputDataType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInputData").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list3.add(InputDataType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone3 = false; + while(!loopDone3){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone3 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInputData").equals(reader.getName())){ + list3.add(InputDataType.Factory.parse(reader)); + + }else{ + loopDone3 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReferenceInputData((InputDataType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + InputDataType.class, + list3)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck").equals(reader.getName())){ + + object.setSignatureCheck(ReferencesCheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheck").equals(reader.getName())){ + + object.setSignatureManifestCheck(ReferencesCheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLDSIGManifestCheck").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list6.add(ManifestRefsCheckResultType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone6 = false; + while(!loopDone6){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone6 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLDSIGManifestCheck").equals(reader.getName())){ + list6.add(ManifestRefsCheckResultType.Factory.parse(reader)); + + }else{ + loopDone6 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setXMLDSIGManifestCheck((ManifestRefsCheckResultType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ManifestRefsCheckResultType.class, + list6)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck").equals(reader.getName())){ + + object.setCertificateCheck(CheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsInfoProfile_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyTransformsInfoProfile_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for TransformParameter + * This was an Array! + */ + + + protected TransformParameterType[] localTransformParameter ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformParameterTracker = false ; + + public boolean isTransformParameterSpecified(){ + return localTransformParameterTracker; + } + + + + /** + * Auto generated getter method + * @return TransformParameterType[] + */ + public TransformParameterType[] getTransformParameter(){ + return localTransformParameter; + } + + + + + + + /** + * validate the array for TransformParameter + */ + protected void validateTransformParameter(TransformParameterType[] param){ + + } + + + /** + * Auto generated setter method + * @param param TransformParameter + */ + public void setTransformParameter(TransformParameterType[] param){ + + validateTransformParameter(param); + + localTransformParameterTracker = param != null; + + this.localTransformParameter=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param TransformParameterType + */ + public void addTransformParameter(TransformParameterType param){ + if (localTransformParameter == null){ + localTransformParameter = new TransformParameterType[]{}; + } + + + //update the setting tracker + localTransformParameterTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localTransformParameter); + list.add(param); + this.localTransformParameter = + (TransformParameterType[])list.toArray( + new TransformParameterType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyTransformsInfoProfile_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyTransformsInfoProfile_type0", + xmlWriter); + } + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } if (localTransformParameterTracker){ + if (localTransformParameter!=null){ + for (int i = 0;i < localTransformParameter.length;i++){ + if (localTransformParameter[i] != null){ + localTransformParameter[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TransformParameter"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("TransformParameter cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } if (localTransformParameterTracker){ + if (localTransformParameter!=null) { + for (int i = 0;i < localTransformParameter.length;i++){ + + if (localTransformParameter[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TransformParameter")); + elementList.add(localTransformParameter[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("TransformParameter cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsInfoProfile_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsInfoProfile_type0 object = + new VerifyTransformsInfoProfile_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyTransformsInfoProfile_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyTransformsInfoProfile_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TransformParameter").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(TransformParameterType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TransformParameter").equals(reader.getName())){ + list2.add(TransformParameterType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setTransformParameter((TransformParameterType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + TransformParameterType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SPKIData + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SPKIData", + "ns1"); + + + + /** + * field for SPKIData + */ + + + protected SPKIDataType localSPKIData ; + + + /** + * Auto generated getter method + * @return SPKIDataType + */ + public SPKIDataType getSPKIData(){ + return localSPKIData; + } + + + + /** + * Auto generated setter method + * @param param SPKIData + */ + public void setSPKIData(SPKIDataType param){ + + this.localSPKIData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSPKIData==null){ + throw new org.apache.axis2.databinding.ADBException("SPKIData cannot be null!"); + } + localSPKIData.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSPKIData.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SPKIData parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SPKIData object = + new SPKIData(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKIData").equals(reader.getName())){ + + object.setSPKIData(SPKIDataType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSDataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSDataObjectInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObject + */ + + + protected DataObject_type1 localDataObject ; + + + /** + * Auto generated getter method + * @return DataObject_type1 + */ + public DataObject_type1 getDataObject(){ + return localDataObject; + } + + + + /** + * Auto generated setter method + * @param param DataObject + */ + public void setDataObject(DataObject_type1 param){ + + this.localDataObject=param; + + + } + + + /** + * field for Structure + * This was an Attribute! + */ + + + protected Structure_type1 localStructure ; + + + /** + * Auto generated getter method + * @return Structure_type1 + */ + public Structure_type1 getStructure(){ + return localStructure; + } + + + + /** + * Auto generated setter method + * @param param Structure + */ + public void setStructure(Structure_type1 param){ + + this.localStructure=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSDataObjectInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSDataObjectInfoType", + xmlWriter); + } + + + } + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSDataObjectInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSDataObjectInfoType object = + new CMSDataObjectInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSDataObjectInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSDataObjectInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type1.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type1.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PartOf_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "PartOf_type0", + "ns2"); + + + + /** + * field for PartOf_type0 + */ + + + protected org.apache.axis2.databinding.types.Token localPartOf_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected PartOf_type0(org.apache.axis2.databinding.types.Token value, boolean isRegisterValue) { + localPartOf_type0 = value; + if (isRegisterValue){ + + _table_.put(localPartOf_type0, this); + + } + + } + + public static final org.apache.axis2.databinding.types.Token _SignedInfo = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("SignedInfo"); + + public static final org.apache.axis2.databinding.types.Token _XMLDSIGManifest = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("XMLDSIGManifest"); + + public static final PartOf_type0 SignedInfo = + new PartOf_type0(_SignedInfo,true); + + public static final PartOf_type0 XMLDSIGManifest = + new PartOf_type0(_XMLDSIGManifest,true); + + + public org.apache.axis2.databinding.types.Token getValue() { return localPartOf_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localPartOf_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PartOf_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PartOf_type0", + xmlWriter); + } + } + + if (localPartOf_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("PartOf_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPartOf_type0)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localPartOf_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static PartOf_type0 fromValue(org.apache.axis2.databinding.types.Token value) + throws java.lang.IllegalArgumentException { + PartOf_type0 enumeration = (PartOf_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static PartOf_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static PartOf_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return PartOf_type0.Factory.fromString(content,namespaceUri); + } else { + return PartOf_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PartOf_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PartOf_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"PartOf_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = PartOf_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = PartOf_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValueTypeSequence_type1 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DSAKeyValueTypeSequence_type1 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Seed + */ + + + protected CryptoBinary localSeed ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getSeed(){ + return localSeed; + } + + + + /** + * Auto generated setter method + * @param param Seed + */ + public void setSeed(CryptoBinary param){ + + this.localSeed=param; + + + } + + + /** + * field for PgenCounter + */ + + + protected CryptoBinary localPgenCounter ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getPgenCounter(){ + return localPgenCounter; + } + + + + /** + * Auto generated setter method + * @param param PgenCounter + */ + public void setPgenCounter(CryptoBinary param){ + + this.localPgenCounter=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DSAKeyValueTypeSequence_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DSAKeyValueTypeSequence_type1", + xmlWriter); + } + + + } + + if (localSeed==null){ + throw new org.apache.axis2.databinding.ADBException("Seed cannot be null!!"); + } + localSeed.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Seed"), + xmlWriter); + + if (localPgenCounter==null){ + throw new org.apache.axis2.databinding.ADBException("PgenCounter cannot be null!!"); + } + localPgenCounter.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PgenCounter"), + xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Seed")); + + + if (localSeed==null){ + throw new org.apache.axis2.databinding.ADBException("Seed cannot be null!!"); + } + elementList.add(localSeed); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PgenCounter")); + + + if (localPgenCounter==null){ + throw new org.apache.axis2.databinding.ADBException("PgenCounter cannot be null!!"); + } + elementList.add(localPgenCounter); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValueTypeSequence_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValueTypeSequence_type1 object = + new DSAKeyValueTypeSequence_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Seed").equals(reader.getName())){ + + object.setSeed(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PgenCounter").equals(reader.getName())){ + + object.setPgenCounter(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValueTypeSequence_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DSAKeyValueTypeSequence_type0 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for P + */ + + + protected CryptoBinary localP ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getP(){ + return localP; + } + + + + /** + * Auto generated setter method + * @param param P + */ + public void setP(CryptoBinary param){ + + this.localP=param; + + + } + + + /** + * field for Q + */ + + + protected CryptoBinary localQ ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getQ(){ + return localQ; + } + + + + /** + * Auto generated setter method + * @param param Q + */ + public void setQ(CryptoBinary param){ + + this.localQ=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DSAKeyValueTypeSequence_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DSAKeyValueTypeSequence_type0", + xmlWriter); + } + + + } + + if (localP==null){ + throw new org.apache.axis2.databinding.ADBException("P cannot be null!!"); + } + localP.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","P"), + xmlWriter); + + if (localQ==null){ + throw new org.apache.axis2.databinding.ADBException("Q cannot be null!!"); + } + localQ.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Q"), + xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "P")); + + + if (localP==null){ + throw new org.apache.axis2.databinding.ADBException("P cannot be null!!"); + } + elementList.add(localP); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Q")); + + + if (localQ==null){ + throw new org.apache.axis2.databinding.ADBException("Q cannot be null!!"); + } + elementList.add(localQ); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValueTypeSequence_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValueTypeSequence_type0 object = + new DSAKeyValueTypeSequence_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","P").equals(reader.getName())){ + + object.setP(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Q").equals(reader.getName())){ + + object.setQ(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509DataTypeChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509DataTypeChoice_type0 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localX509IssuerSerialTracker = false; + + localX509SKITracker = false; + + localX509SubjectNameTracker = false; + + localX509CertificateTracker = false; + + localX509CRLTracker = false; + + localExtraElementTracker = false; + + } + + + /** + * field for X509IssuerSerial + */ + + + protected X509IssuerSerialType localX509IssuerSerial ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509IssuerSerialTracker = false ; + + public boolean isX509IssuerSerialSpecified(){ + return localX509IssuerSerialTracker; + } + + + + /** + * Auto generated getter method + * @return X509IssuerSerialType + */ + public X509IssuerSerialType getX509IssuerSerial(){ + return localX509IssuerSerial; + } + + + + /** + * Auto generated setter method + * @param param X509IssuerSerial + */ + public void setX509IssuerSerial(X509IssuerSerialType param){ + + clearAllSettingTrackers(); + localX509IssuerSerialTracker = param != null; + + this.localX509IssuerSerial=param; + + + } + + + /** + * field for X509SKI + */ + + + protected javax.activation.DataHandler localX509SKI ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509SKITracker = false ; + + public boolean isX509SKISpecified(){ + return localX509SKITracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getX509SKI(){ + return localX509SKI; + } + + + + /** + * Auto generated setter method + * @param param X509SKI + */ + public void setX509SKI(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localX509SKITracker = param != null; + + this.localX509SKI=param; + + + } + + + /** + * field for X509SubjectName + */ + + + protected java.lang.String localX509SubjectName ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509SubjectNameTracker = false ; + + public boolean isX509SubjectNameSpecified(){ + return localX509SubjectNameTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getX509SubjectName(){ + return localX509SubjectName; + } + + + + /** + * Auto generated setter method + * @param param X509SubjectName + */ + public void setX509SubjectName(java.lang.String param){ + + clearAllSettingTrackers(); + localX509SubjectNameTracker = param != null; + + this.localX509SubjectName=param; + + + } + + + /** + * field for X509Certificate + */ + + + protected javax.activation.DataHandler localX509Certificate ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509CertificateTracker = false ; + + public boolean isX509CertificateSpecified(){ + return localX509CertificateTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getX509Certificate(){ + return localX509Certificate; + } + + + + /** + * Auto generated setter method + * @param param X509Certificate + */ + public void setX509Certificate(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localX509CertificateTracker = param != null; + + this.localX509Certificate=param; + + + } + + + /** + * field for X509CRL + */ + + + protected javax.activation.DataHandler localX509CRL ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509CRLTracker = false ; + + public boolean isX509CRLSpecified(){ + return localX509CRLTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getX509CRL(){ + return localX509CRL; + } + + + + /** + * Auto generated setter method + * @param param X509CRL + */ + public void setX509CRL(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localX509CRLTracker = param != null; + + this.localX509CRL=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509DataTypeChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509DataTypeChoice_type0", + xmlWriter); + } + + + } + if (localX509IssuerSerialTracker){ + if (localX509IssuerSerial==null){ + throw new org.apache.axis2.databinding.ADBException("X509IssuerSerial cannot be null!!"); + } + localX509IssuerSerial.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509IssuerSerial"), + xmlWriter); + } if (localX509SKITracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509SKI", xmlWriter); + + + if (localX509SKI!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localX509SKI, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for X509SKI", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localX509SubjectNameTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509SubjectName", xmlWriter); + + + if (localX509SubjectName==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("X509SubjectName cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localX509SubjectName); + + } + + xmlWriter.writeEndElement(); + } if (localX509CertificateTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509Certificate", xmlWriter); + + + if (localX509Certificate!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localX509Certificate, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for X509Certificate", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localX509CRLTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509CRL", xmlWriter); + + + if (localX509CRL!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localX509CRL, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for X509CRL", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localX509IssuerSerialTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509IssuerSerial")); + + + if (localX509IssuerSerial==null){ + throw new org.apache.axis2.databinding.ADBException("X509IssuerSerial cannot be null!!"); + } + elementList.add(localX509IssuerSerial); + } if (localX509SKITracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509SKI")); + + elementList.add(localX509SKI); + } if (localX509SubjectNameTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509SubjectName")); + + if (localX509SubjectName != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509SubjectName)); + } else { + throw new org.apache.axis2.databinding.ADBException("X509SubjectName cannot be null!!"); + } + } if (localX509CertificateTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509Certificate")); + + elementList.add(localX509Certificate); + } if (localX509CRLTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509CRL")); + + elementList.add(localX509CRL); + } if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509DataTypeChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509DataTypeChoice_type0 object = + new X509DataTypeChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509IssuerSerial").equals(reader.getName())){ + + object.setX509IssuerSerial(X509IssuerSerialType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509SKI").equals(reader.getName())){ + + object.setX509SKI(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509SubjectName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"X509SubjectName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setX509SubjectName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Certificate").equals(reader.getName())){ + + object.setX509Certificate(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509CRL").equals(reader.getName())){ + + object.setX509CRL(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname6 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder6 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname6); + object.setExtraElement(builder6.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureRequest extends VerifyCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyCMSSignatureRequest", + "ns2"); + + + + /** + * field for Signatories + * This was an Attribute! + */ + + + protected SignatoriesType localSignatories ; + + + /** + * Auto generated getter method + * @return SignatoriesType + */ + public SignatoriesType getSignatories(){ + return localSignatories; + } + + + + /** + * Auto generated setter method + * @param param Signatories + */ + public void setSignatories(SignatoriesType param){ + + this.localSignatories=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureRequest", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureRequest", + xmlWriter); + } + + + } + + + if (localSignatories != null){ + writeAttribute("", + "Signatories", + localSignatories.toString(), xmlWriter); + } + if (localDateTimeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "DateTime", xmlWriter); + + + if (localDateTime==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + + } + + xmlWriter.writeEndElement(); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "CMSSignature", xmlWriter); + + + if (localCMSSignature!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localCMSSignature, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for CMSSignature", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localDataObjectTracker){ + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "TrustProfileID", xmlWriter); + + + if (localTrustProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyCMSSignatureRequest")); + if (localDateTimeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DateTime")); + + if (localDateTime != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + } else { + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CMSSignature")); + + elementList.add(localCMSSignature); + if (localDataObjectTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TrustProfileID")); + + if (localTrustProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Signatories")); + + attribList.add(localSignatories.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureRequest object = + new VerifyCMSSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyCMSSignatureRequest".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyCMSSignatureRequest)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Signatories" + java.lang.String tempAttribSignatories = + + reader.getAttributeValue(null,"Signatories"); + + if (tempAttribSignatories!=null){ + java.lang.String content = tempAttribSignatories; + + object.setSignatories( + SignatoriesType.Factory.fromString(reader,tempAttribSignatories)); + + } else { + + } + handledAttributes.add("Signatories"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DateTime").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DateTime" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDateTime( + org.apache.axis2.databinding.utils.ConverterUtil.convertToDateTime(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CMSSignature").equals(reader.getName())){ + + object.setCMSSignature(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(CMSDataObjectOptionalMetaType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TrustProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"TrustProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setTrustProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PublicAuthority + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "PublicAuthority", + "ns2"); + + + + /** + * field for PublicAuthority + */ + + + protected PublicAuthorityType localPublicAuthority ; + + + /** + * Auto generated getter method + * @return PublicAuthorityType + */ + public PublicAuthorityType getPublicAuthority(){ + return localPublicAuthority; + } + + + + /** + * Auto generated setter method + * @param param PublicAuthority + */ + public void setPublicAuthority(PublicAuthorityType param){ + + this.localPublicAuthority=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localPublicAuthority==null){ + throw new org.apache.axis2.databinding.ADBException("PublicAuthority cannot be null!"); + } + localPublicAuthority.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localPublicAuthority.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PublicAuthority parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PublicAuthority object = + new PublicAuthority(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","PublicAuthority").equals(reader.getName())){ + + object.setPublicAuthority(PublicAuthorityType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ManifestRefsCheckResultInfoType extends AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ManifestRefsCheckResultInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for FailedReference + * This was an Array! + */ + + + protected org.apache.axis2.databinding.types.PositiveInteger[] localFailedReference ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localFailedReferenceTracker = false ; + + public boolean isFailedReferenceSpecified(){ + return localFailedReferenceTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.PositiveInteger[] + */ + public org.apache.axis2.databinding.types.PositiveInteger[] getFailedReference(){ + return localFailedReference; + } + + + + + + + /** + * validate the array for FailedReference + */ + protected void validateFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + } + + + /** + * Auto generated setter method + * @param param FailedReference + */ + public void setFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + validateFailedReference(param); + + localFailedReferenceTracker = param != null; + + this.localFailedReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axis2.databinding.types.PositiveInteger + */ + public void addFailedReference(org.apache.axis2.databinding.types.PositiveInteger param){ + if (localFailedReference == null){ + localFailedReference = new org.apache.axis2.databinding.types.PositiveInteger[]{}; + } + + + //update the setting tracker + localFailedReferenceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localFailedReference); + list.add(param); + this.localFailedReference = + (org.apache.axis2.databinding.types.PositiveInteger[])list.toArray( + new org.apache.axis2.databinding.types.PositiveInteger[list.size()]); + + } + + + /** + * field for ReferringSigReference + */ + + + protected org.apache.axis2.databinding.types.PositiveInteger localReferringSigReference ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.PositiveInteger + */ + public org.apache.axis2.databinding.types.PositiveInteger getReferringSigReference(){ + return localReferringSigReference; + } + + + + /** + * Auto generated setter method + * @param param ReferringSigReference + */ + public void setReferringSigReference(org.apache.axis2.databinding.types.PositiveInteger param){ + + this.localReferringSigReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ManifestRefsCheckResultInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ManifestRefsCheckResultInfoType", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null) { + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + + writeStartElement(null, namespace, "FailedReference", xmlWriter); + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + + xmlWriter.writeEndElement(); + + } else { + + // we have to do nothing since minOccurs is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "ReferringSigReference", xmlWriter); + + + if (localReferringSigReference==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("ReferringSigReference cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null){ + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "FailedReference")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + } else { + + // have to do nothing + + } + + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReferringSigReference")); + + if (localReferringSigReference != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference)); + } else { + throw new org.apache.axis2.databinding.ADBException("ReferringSigReference cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ManifestRefsCheckResultInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ManifestRefsCheckResultInfoType object = + new ManifestRefsCheckResultInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ManifestRefsCheckResultInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ManifestRefsCheckResultInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(reader.getElementText()); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // Ensure we are at the EndElement + while (!reader.isEndElement()){ + reader.next(); + } + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + list2.add(reader.getElementText()); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setFailedReference((org.apache.axis2.databinding.types.PositiveInteger[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axis2.databinding.types.PositiveInteger.class,list2)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferringSigReference").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ReferringSigReference" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setReferringSigReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToPositiveInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CanonicalizationMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "CanonicalizationMethod", + "ns1"); + + + + /** + * field for CanonicalizationMethod + */ + + + protected CanonicalizationMethodType localCanonicalizationMethod ; + + + /** + * Auto generated getter method + * @return CanonicalizationMethodType + */ + public CanonicalizationMethodType getCanonicalizationMethod(){ + return localCanonicalizationMethod; + } + + + + /** + * Auto generated setter method + * @param param CanonicalizationMethod + */ + public void setCanonicalizationMethod(CanonicalizationMethodType param){ + + this.localCanonicalizationMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCanonicalizationMethod==null){ + throw new org.apache.axis2.databinding.ADBException("CanonicalizationMethod cannot be null!"); + } + localCanonicalizationMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCanonicalizationMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CanonicalizationMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CanonicalizationMethod object = + new CanonicalizationMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","CanonicalizationMethod").equals(reader.getName())){ + + object.setCanonicalizationMethod(CanonicalizationMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = AnyChildrenType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":AnyChildrenType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "AnyChildrenType", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static AnyChildrenType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + AnyChildrenType object = + new AnyChildrenType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"AnyChildrenType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (AnyChildrenType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyInfoTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = KeyInfoTypeChoice + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localKeyNameTracker = false; + + localKeyValueTracker = false; + + localRetrievalMethodTracker = false; + + localX509DataTracker = false; + + localPGPDataTracker = false; + + localSPKIDataTracker = false; + + localMgmtDataTracker = false; + + localExtraElementTracker = false; + + } + + + /** + * field for KeyName + */ + + + protected java.lang.String localKeyName ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localKeyNameTracker = false ; + + public boolean isKeyNameSpecified(){ + return localKeyNameTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getKeyName(){ + return localKeyName; + } + + + + /** + * Auto generated setter method + * @param param KeyName + */ + public void setKeyName(java.lang.String param){ + + clearAllSettingTrackers(); + localKeyNameTracker = param != null; + + this.localKeyName=param; + + + } + + + /** + * field for KeyValue + */ + + + protected KeyValueType localKeyValue ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localKeyValueTracker = false ; + + public boolean isKeyValueSpecified(){ + return localKeyValueTracker; + } + + + + /** + * Auto generated getter method + * @return KeyValueType + */ + public KeyValueType getKeyValue(){ + return localKeyValue; + } + + + + /** + * Auto generated setter method + * @param param KeyValue + */ + public void setKeyValue(KeyValueType param){ + + clearAllSettingTrackers(); + localKeyValueTracker = param != null; + + this.localKeyValue=param; + + + } + + + /** + * field for RetrievalMethod + */ + + + protected RetrievalMethodType localRetrievalMethod ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localRetrievalMethodTracker = false ; + + public boolean isRetrievalMethodSpecified(){ + return localRetrievalMethodTracker; + } + + + + /** + * Auto generated getter method + * @return RetrievalMethodType + */ + public RetrievalMethodType getRetrievalMethod(){ + return localRetrievalMethod; + } + + + + /** + * Auto generated setter method + * @param param RetrievalMethod + */ + public void setRetrievalMethod(RetrievalMethodType param){ + + clearAllSettingTrackers(); + localRetrievalMethodTracker = param != null; + + this.localRetrievalMethod=param; + + + } + + + /** + * field for X509Data + */ + + + protected X509DataType localX509Data ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localX509DataTracker = false ; + + public boolean isX509DataSpecified(){ + return localX509DataTracker; + } + + + + /** + * Auto generated getter method + * @return X509DataType + */ + public X509DataType getX509Data(){ + return localX509Data; + } + + + + /** + * Auto generated setter method + * @param param X509Data + */ + public void setX509Data(X509DataType param){ + + clearAllSettingTrackers(); + localX509DataTracker = param != null; + + this.localX509Data=param; + + + } + + + /** + * field for PGPData + */ + + + protected PGPDataType localPGPData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPDataTracker = false ; + + public boolean isPGPDataSpecified(){ + return localPGPDataTracker; + } + + + + /** + * Auto generated getter method + * @return PGPDataType + */ + public PGPDataType getPGPData(){ + return localPGPData; + } + + + + /** + * Auto generated setter method + * @param param PGPData + */ + public void setPGPData(PGPDataType param){ + + clearAllSettingTrackers(); + localPGPDataTracker = param != null; + + this.localPGPData=param; + + + } + + + /** + * field for SPKIData + */ + + + protected SPKIDataType localSPKIData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSPKIDataTracker = false ; + + public boolean isSPKIDataSpecified(){ + return localSPKIDataTracker; + } + + + + /** + * Auto generated getter method + * @return SPKIDataType + */ + public SPKIDataType getSPKIData(){ + return localSPKIData; + } + + + + /** + * Auto generated setter method + * @param param SPKIData + */ + public void setSPKIData(SPKIDataType param){ + + clearAllSettingTrackers(); + localSPKIDataTracker = param != null; + + this.localSPKIData=param; + + + } + + + /** + * field for MgmtData + */ + + + protected java.lang.String localMgmtData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localMgmtDataTracker = false ; + + public boolean isMgmtDataSpecified(){ + return localMgmtDataTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getMgmtData(){ + return localMgmtData; + } + + + + /** + * Auto generated setter method + * @param param MgmtData + */ + public void setMgmtData(java.lang.String param){ + + clearAllSettingTrackers(); + localMgmtDataTracker = param != null; + + this.localMgmtData=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyInfoTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyInfoTypeChoice", + xmlWriter); + } + + + } + if (localKeyNameTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "KeyName", xmlWriter); + + + if (localKeyName==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("KeyName cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localKeyName); + + } + + xmlWriter.writeEndElement(); + } if (localKeyValueTracker){ + if (localKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("KeyValue cannot be null!!"); + } + localKeyValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyValue"), + xmlWriter); + } if (localRetrievalMethodTracker){ + if (localRetrievalMethod==null){ + throw new org.apache.axis2.databinding.ADBException("RetrievalMethod cannot be null!!"); + } + localRetrievalMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RetrievalMethod"), + xmlWriter); + } if (localX509DataTracker){ + if (localX509Data==null){ + throw new org.apache.axis2.databinding.ADBException("X509Data cannot be null!!"); + } + localX509Data.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Data"), + xmlWriter); + } if (localPGPDataTracker){ + if (localPGPData==null){ + throw new org.apache.axis2.databinding.ADBException("PGPData cannot be null!!"); + } + localPGPData.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPData"), + xmlWriter); + } if (localSPKIDataTracker){ + if (localSPKIData==null){ + throw new org.apache.axis2.databinding.ADBException("SPKIData cannot be null!!"); + } + localSPKIData.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKIData"), + xmlWriter); + } if (localMgmtDataTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "MgmtData", xmlWriter); + + + if (localMgmtData==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("MgmtData cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localMgmtData); + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localKeyNameTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyName")); + + if (localKeyName != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localKeyName)); + } else { + throw new org.apache.axis2.databinding.ADBException("KeyName cannot be null!!"); + } + } if (localKeyValueTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyValue")); + + + if (localKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("KeyValue cannot be null!!"); + } + elementList.add(localKeyValue); + } if (localRetrievalMethodTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "RetrievalMethod")); + + + if (localRetrievalMethod==null){ + throw new org.apache.axis2.databinding.ADBException("RetrievalMethod cannot be null!!"); + } + elementList.add(localRetrievalMethod); + } if (localX509DataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509Data")); + + + if (localX509Data==null){ + throw new org.apache.axis2.databinding.ADBException("X509Data cannot be null!!"); + } + elementList.add(localX509Data); + } if (localPGPDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPData")); + + + if (localPGPData==null){ + throw new org.apache.axis2.databinding.ADBException("PGPData cannot be null!!"); + } + elementList.add(localPGPData); + } if (localSPKIDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SPKIData")); + + + if (localSPKIData==null){ + throw new org.apache.axis2.databinding.ADBException("SPKIData cannot be null!!"); + } + elementList.add(localSPKIData); + } if (localMgmtDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "MgmtData")); + + if (localMgmtData != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMgmtData)); + } else { + throw new org.apache.axis2.databinding.ADBException("MgmtData cannot be null!!"); + } + } if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyInfoTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyInfoTypeChoice object = + new KeyInfoTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"KeyName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setKeyName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyValue").equals(reader.getName())){ + + object.setKeyValue(KeyValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RetrievalMethod").equals(reader.getName())){ + + object.setRetrievalMethod(RetrievalMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Data").equals(reader.getName())){ + + object.setX509Data(X509DataType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPData").equals(reader.getName())){ + + object.setPGPData(PGPDataType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKIData").equals(reader.getName())){ + + object.setSPKIData(SPKIDataType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","MgmtData").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"MgmtData" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setMgmtData( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname8 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder8 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname8); + object.setExtraElement(builder8.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class XMLContentType extends AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = XMLContentType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Space + * This was an Attribute! + */ + + + protected Space_type0 localSpace ; + + + /** + * Auto generated getter method + * @return Space_type0 + */ + public Space_type0 getSpace(){ + return localSpace; + } + + + + /** + * Auto generated setter method + * @param param Space + */ + public void setSpace(Space_type0 param){ + + this.localSpace=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":XMLContentType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "XMLContentType", + xmlWriter); + } + + + + if (localSpace != null){ + writeAttribute("http://www.w3.org/XML/1998/namespace", + "space", + localSpace.toString(), xmlWriter); + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContentType")); + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("http://www.w3.org/XML/1998/namespace","space")); + + attribList.add(localSpace.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static XMLContentType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + XMLContentType object = + new XMLContentType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"XMLContentType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (XMLContentType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "space" + java.lang.String tempAttribSpace = + + reader.getAttributeValue("http://www.w3.org/XML/1998/namespace","space"); + + if (tempAttribSpace!=null){ + java.lang.String content = tempAttribSpace; + + object.setSpace( + Space_type0.Factory.fromString(reader,tempAttribSpace)); + + } else { + + } + handledAttributes.add("space"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObject + */ + + + protected DataObject_type0 localDataObject ; + + + /** + * Auto generated getter method + * @return DataObject_type0 + */ + public DataObject_type0 getDataObject(){ + return localDataObject; + } + + + + /** + * Auto generated setter method + * @param param DataObject + */ + public void setDataObject(DataObject_type0 param){ + + this.localDataObject=param; + + + } + + + /** + * field for DataObjectInfoTypeChoice_type0 + */ + + + protected DataObjectInfoTypeChoice_type0 localDataObjectInfoTypeChoice_type0 ; + + + /** + * Auto generated getter method + * @return DataObjectInfoTypeChoice_type0 + */ + public DataObjectInfoTypeChoice_type0 getDataObjectInfoTypeChoice_type0(){ + return localDataObjectInfoTypeChoice_type0; + } + + + + /** + * Auto generated setter method + * @param param DataObjectInfoTypeChoice_type0 + */ + public void setDataObjectInfoTypeChoice_type0(DataObjectInfoTypeChoice_type0 param){ + + this.localDataObjectInfoTypeChoice_type0=param; + + + } + + + /** + * field for Structure + * This was an Attribute! + */ + + + protected Structure_type0 localStructure ; + + + /** + * Auto generated getter method + * @return Structure_type0 + */ + public Structure_type0 getStructure(){ + return localStructure; + } + + + + /** + * Auto generated setter method + * @param param Structure + */ + public void setStructure(Structure_type0 param){ + + this.localStructure=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfoType", + xmlWriter); + } + + + } + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + localDataObjectInfoTypeChoice_type0.serialize(null,xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfoTypeChoice_type0")); + + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + elementList.add(localDataObjectInfoTypeChoice_type0); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfoType object = + new DataObjectInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObjectInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObjectInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type0.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + object.setDataObjectInfoTypeChoice_type0(DataObjectInfoTypeChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateCMSSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateCMSSignatureResponseTypeChoice + * This was an Array! + */ + + + protected CreateCMSSignatureResponseTypeChoice[] localCreateCMSSignatureResponseTypeChoice ; + + + /** + * Auto generated getter method + * @return CreateCMSSignatureResponseTypeChoice[] + */ + public CreateCMSSignatureResponseTypeChoice[] getCreateCMSSignatureResponseTypeChoice(){ + return localCreateCMSSignatureResponseTypeChoice; + } + + + + + + + /** + * validate the array for CreateCMSSignatureResponseTypeChoice + */ + protected void validateCreateCMSSignatureResponseTypeChoice(CreateCMSSignatureResponseTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param CreateCMSSignatureResponseTypeChoice + */ + public void setCreateCMSSignatureResponseTypeChoice(CreateCMSSignatureResponseTypeChoice[] param){ + + validateCreateCMSSignatureResponseTypeChoice(param); + + + this.localCreateCMSSignatureResponseTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param CreateCMSSignatureResponseTypeChoice + */ + public void addCreateCMSSignatureResponseTypeChoice(CreateCMSSignatureResponseTypeChoice param){ + if (localCreateCMSSignatureResponseTypeChoice == null){ + localCreateCMSSignatureResponseTypeChoice = new CreateCMSSignatureResponseTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localCreateCMSSignatureResponseTypeChoice); + list.add(param); + this.localCreateCMSSignatureResponseTypeChoice = + (CreateCMSSignatureResponseTypeChoice[])list.toArray( + new CreateCMSSignatureResponseTypeChoice[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureResponseType", + xmlWriter); + } + + + } + + + if (localCreateCMSSignatureResponseTypeChoice!=null){ + for (int i = 0;i < localCreateCMSSignatureResponseTypeChoice.length;i++){ + if (localCreateCMSSignatureResponseTypeChoice[i] != null){ + localCreateCMSSignatureResponseTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localCreateCMSSignatureResponseTypeChoice!=null) { + for (int i = 0;i < localCreateCMSSignatureResponseTypeChoice.length;i++){ + + if (localCreateCMSSignatureResponseTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateCMSSignatureResponseTypeChoice")); + elementList.add(localCreateCMSSignatureResponseTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponseTypeChoice cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureResponseType object = + new CreateCMSSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateCMSSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateCMSSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(CreateCMSSignatureResponseTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(CreateCMSSignatureResponseTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setCreateCMSSignatureResponseTypeChoice((CreateCMSSignatureResponseTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + CreateCMSSignatureResponseTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PGPDataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PGPDataType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localPGPDataTypeSequence_type0Tracker = false; + + localPGPDataTypeSequence_type1Tracker = false; + + } + + + /** + * field for PGPDataTypeSequence_type0 + */ + + + protected PGPDataTypeSequence_type0 localPGPDataTypeSequence_type0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPDataTypeSequence_type0Tracker = false ; + + public boolean isPGPDataTypeSequence_type0Specified(){ + return localPGPDataTypeSequence_type0Tracker; + } + + + + /** + * Auto generated getter method + * @return PGPDataTypeSequence_type0 + */ + public PGPDataTypeSequence_type0 getPGPDataTypeSequence_type0(){ + return localPGPDataTypeSequence_type0; + } + + + + /** + * Auto generated setter method + * @param param PGPDataTypeSequence_type0 + */ + public void setPGPDataTypeSequence_type0(PGPDataTypeSequence_type0 param){ + + clearAllSettingTrackers(); + localPGPDataTypeSequence_type0Tracker = param != null; + + this.localPGPDataTypeSequence_type0=param; + + + } + + + /** + * field for PGPDataTypeSequence_type1 + */ + + + protected PGPDataTypeSequence_type1 localPGPDataTypeSequence_type1 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPDataTypeSequence_type1Tracker = false ; + + public boolean isPGPDataTypeSequence_type1Specified(){ + return localPGPDataTypeSequence_type1Tracker; + } + + + + /** + * Auto generated getter method + * @return PGPDataTypeSequence_type1 + */ + public PGPDataTypeSequence_type1 getPGPDataTypeSequence_type1(){ + return localPGPDataTypeSequence_type1; + } + + + + /** + * Auto generated setter method + * @param param PGPDataTypeSequence_type1 + */ + public void setPGPDataTypeSequence_type1(PGPDataTypeSequence_type1 param){ + + clearAllSettingTrackers(); + localPGPDataTypeSequence_type1Tracker = param != null; + + this.localPGPDataTypeSequence_type1=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PGPDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PGPDataType", + xmlWriter); + } + + + } + if (localPGPDataTypeSequence_type0Tracker){ + if (localPGPDataTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type0 cannot be null!!"); + } + localPGPDataTypeSequence_type0.serialize(null,xmlWriter); + } if (localPGPDataTypeSequence_type1Tracker){ + if (localPGPDataTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type1 cannot be null!!"); + } + localPGPDataTypeSequence_type1.serialize(null,xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localPGPDataTypeSequence_type0Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPDataTypeSequence_type0")); + + + if (localPGPDataTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type0 cannot be null!!"); + } + elementList.add(localPGPDataTypeSequence_type0); + } if (localPGPDataTypeSequence_type1Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPDataTypeSequence_type1")); + + + if (localPGPDataTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("PGPDataTypeSequence_type1 cannot be null!!"); + } + elementList.add(localPGPDataTypeSequence_type1); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPDataType object = + new PGPDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"PGPDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (PGPDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setPGPDataTypeSequence_type0(PGPDataTypeSequence_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + + } catch (java.lang.Exception e) {} + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setPGPDataTypeSequence_type1(PGPDataTypeSequence_type1.Factory.parse(reader)); + + } // End of if for expected property start element + + + } catch (java.lang.Exception e) {} + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Manifest + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Manifest", + "ns1"); + + + + /** + * field for Manifest + */ + + + protected ManifestType localManifest ; + + + /** + * Auto generated getter method + * @return ManifestType + */ + public ManifestType getManifest(){ + return localManifest; + } + + + + /** + * Auto generated setter method + * @param param Manifest + */ + public void setManifest(ManifestType param){ + + this.localManifest=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localManifest==null){ + throw new org.apache.axis2.databinding.ADBException("Manifest cannot be null!"); + } + localManifest.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localManifest.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Manifest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Manifest object = + new Manifest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Manifest").equals(reader.getName())){ + + object.setManifest(ManifestType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Transforms + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Transforms", + "ns1"); + + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + + this.localTransforms=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!"); + } + localTransforms.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localTransforms.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Transforms parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Transforms object = + new Transforms(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class FinalDataMetaInfoType extends MetaInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = FinalDataMetaInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Type + */ + + + protected org.apache.axis2.databinding.types.URI localType ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTypeTracker = false ; + + public boolean isTypeSpecified(){ + return localTypeTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getType(){ + return localType; + } + + + + /** + * Auto generated setter method + * @param param Type + */ + public void setType(org.apache.axis2.databinding.types.URI param){ + localTypeTracker = param != null; + + this.localType=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":FinalDataMetaInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "FinalDataMetaInfoType", + xmlWriter); + } + + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + localMimeType.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType"), + xmlWriter); + if (localDescriptionTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Description", xmlWriter); + + + if (localDescription==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localTypeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Type", xmlWriter); + + + if (localType==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Type cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FinalDataMetaInfoType")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MimeType")); + + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + elementList.add(localMimeType); + if (localDescriptionTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Description")); + + if (localDescription != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + } else { + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + } + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localTypeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Type")); + + if (localType != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + } else { + throw new org.apache.axis2.databinding.ADBException("Type cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static FinalDataMetaInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + FinalDataMetaInfoType object = + new FinalDataMetaInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"FinalDataMetaInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (FinalDataMetaInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType").equals(reader.getName())){ + + object.setMimeType(MimeTypeType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Description").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Description" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDescription( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone3=false; + + while (!loopDone3){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list3.add(builder3.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone3 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone3 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list3)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Type").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Type" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SignedInfo + */ + + + protected SignedInfoType localSignedInfo ; + + + /** + * Auto generated getter method + * @return SignedInfoType + */ + public SignedInfoType getSignedInfo(){ + return localSignedInfo; + } + + + + /** + * Auto generated setter method + * @param param SignedInfo + */ + public void setSignedInfo(SignedInfoType param){ + + this.localSignedInfo=param; + + + } + + + /** + * field for SignatureValue + */ + + + protected SignatureValueType localSignatureValue ; + + + /** + * Auto generated getter method + * @return SignatureValueType + */ + public SignatureValueType getSignatureValue(){ + return localSignatureValue; + } + + + + /** + * Auto generated setter method + * @param param SignatureValue + */ + public void setSignatureValue(SignatureValueType param){ + + this.localSignatureValue=param; + + + } + + + /** + * field for KeyInfo + */ + + + protected KeyInfoType localKeyInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localKeyInfoTracker = false ; + + public boolean isKeyInfoSpecified(){ + return localKeyInfoTracker; + } + + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getKeyInfo(){ + return localKeyInfo; + } + + + + /** + * Auto generated setter method + * @param param KeyInfo + */ + public void setKeyInfo(KeyInfoType param){ + localKeyInfoTracker = param != null; + + this.localKeyInfo=param; + + + } + + + /** + * field for Object + * This was an Array! + */ + + + protected ObjectType[] localObject ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localObjectTracker = false ; + + public boolean isObjectSpecified(){ + return localObjectTracker; + } + + + + /** + * Auto generated getter method + * @return ObjectType[] + */ + public ObjectType[] getObject(){ + return localObject; + } + + + + + + + /** + * validate the array for Object + */ + protected void validateObject(ObjectType[] param){ + + } + + + /** + * Auto generated setter method + * @param param Object + */ + public void setObject(ObjectType[] param){ + + validateObject(param); + + localObjectTracker = param != null; + + this.localObject=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ObjectType + */ + public void addObject(ObjectType param){ + if (localObject == null){ + localObject = new ObjectType[]{}; + } + + + //update the setting tracker + localObjectTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localObject); + list.add(param); + this.localObject = + (ObjectType[])list.toArray( + new ObjectType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localSignedInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignedInfo cannot be null!!"); + } + localSignedInfo.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignedInfo"), + xmlWriter); + + if (localSignatureValue==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureValue cannot be null!!"); + } + localSignatureValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureValue"), + xmlWriter); + if (localKeyInfoTracker){ + if (localKeyInfo==null){ + throw new org.apache.axis2.databinding.ADBException("KeyInfo cannot be null!!"); + } + localKeyInfo.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyInfo"), + xmlWriter); + } if (localObjectTracker){ + if (localObject!=null){ + for (int i = 0;i < localObject.length;i++){ + if (localObject[i] != null){ + localObject[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Object cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignedInfo")); + + + if (localSignedInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignedInfo cannot be null!!"); + } + elementList.add(localSignedInfo); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignatureValue")); + + + if (localSignatureValue==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureValue cannot be null!!"); + } + elementList.add(localSignatureValue); + if (localKeyInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyInfo")); + + + if (localKeyInfo==null){ + throw new org.apache.axis2.databinding.ADBException("KeyInfo cannot be null!!"); + } + elementList.add(localKeyInfo); + } if (localObjectTracker){ + if (localObject!=null) { + for (int i = 0;i < localObject.length;i++){ + + if (localObject[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Object")); + elementList.add(localObject[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Object cannot be null!!"); + + } + + } + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureType object = + new SignatureType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list4 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignedInfo").equals(reader.getName())){ + + object.setSignedInfo(SignedInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureValue").equals(reader.getName())){ + + object.setSignatureValue(SignatureValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyInfo").equals(reader.getName())){ + + object.setKeyInfo(KeyInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list4.add(ObjectType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone4 = false; + while(!loopDone4){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone4 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object").equals(reader.getName())){ + list4.add(ObjectType.Factory.parse(reader)); + + }else{ + loopDone4 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setObject((ObjectType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ObjectType.class, + list4)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PGPDataTypeSequence_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PGPDataTypeSequence_type0 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for PGPKeyID + */ + + + protected javax.activation.DataHandler localPGPKeyID ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getPGPKeyID(){ + return localPGPKeyID; + } + + + + /** + * Auto generated setter method + * @param param PGPKeyID + */ + public void setPGPKeyID(javax.activation.DataHandler param){ + + this.localPGPKeyID=param; + + + } + + + /** + * field for PGPKeyPacket + */ + + + protected javax.activation.DataHandler localPGPKeyPacket ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localPGPKeyPacketTracker = false ; + + public boolean isPGPKeyPacketSpecified(){ + return localPGPKeyPacketTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getPGPKeyPacket(){ + return localPGPKeyPacket; + } + + + + /** + * Auto generated setter method + * @param param PGPKeyPacket + */ + public void setPGPKeyPacket(javax.activation.DataHandler param){ + localPGPKeyPacketTracker = param != null; + + this.localPGPKeyPacket=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PGPDataTypeSequence_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PGPDataTypeSequence_type0", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "PGPKeyID", xmlWriter); + + + if (localPGPKeyID!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localPGPKeyID, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for PGPKeyID", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localPGPKeyPacketTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "PGPKeyPacket", xmlWriter); + + + if (localPGPKeyPacket!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localPGPKeyPacket, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for PGPKeyPacket", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPKeyID")); + + elementList.add(localPGPKeyID); + if (localPGPKeyPacketTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPKeyPacket")); + + elementList.add(localPGPKeyPacket); + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPDataTypeSequence_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPDataTypeSequence_type0 object = + new PGPDataTypeSequence_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPKeyID").equals(reader.getName())){ + + object.setPGPKeyID(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPKeyPacket").equals(reader.getName())){ + + object.setPGPKeyPacket(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone3=false; + + while (!loopDone3){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list3.add(builder3.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone3 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone3 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list3)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PGPDataTypeSequence_type1 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PGPDataTypeSequence_type1 + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for PGPKeyPacket + */ + + + protected javax.activation.DataHandler localPGPKeyPacket ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getPGPKeyPacket(){ + return localPGPKeyPacket; + } + + + + /** + * Auto generated setter method + * @param param PGPKeyPacket + */ + public void setPGPKeyPacket(javax.activation.DataHandler param){ + + this.localPGPKeyPacket=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PGPDataTypeSequence_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PGPDataTypeSequence_type1", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "PGPKeyPacket", xmlWriter); + + + if (localPGPKeyPacket!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localPGPKeyPacket, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for PGPKeyPacket", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "PGPKeyPacket")); + + elementList.add(localPGPKeyPacket); + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PGPDataTypeSequence_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PGPDataTypeSequence_type1 object = + new PGPDataTypeSequence_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","PGPKeyPacket").equals(reader.getName())){ + + object.setPGPKeyPacket(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone2=false; + + while (!loopDone2){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder2 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list2.add(builder2.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone2 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone2 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureResponseTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateXMLSignatureResponseTypeChoice + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localSignatureEnvironmentTracker = false; + + localErrorResponseTracker = false; + + } + + + /** + * field for SignatureEnvironment + */ + + + protected SignatureEnvironment_type0 localSignatureEnvironment ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSignatureEnvironmentTracker = false ; + + public boolean isSignatureEnvironmentSpecified(){ + return localSignatureEnvironmentTracker; + } + + + + /** + * Auto generated getter method + * @return SignatureEnvironment_type0 + */ + public SignatureEnvironment_type0 getSignatureEnvironment(){ + return localSignatureEnvironment; + } + + + + /** + * Auto generated setter method + * @param param SignatureEnvironment + */ + public void setSignatureEnvironment(SignatureEnvironment_type0 param){ + + clearAllSettingTrackers(); + localSignatureEnvironmentTracker = param != null; + + this.localSignatureEnvironment=param; + + + } + + + /** + * field for ErrorResponse + */ + + + protected ErrorResponseType localErrorResponse ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localErrorResponseTracker = false ; + + public boolean isErrorResponseSpecified(){ + return localErrorResponseTracker; + } + + + + /** + * Auto generated getter method + * @return ErrorResponseType + */ + public ErrorResponseType getErrorResponse(){ + return localErrorResponse; + } + + + + /** + * Auto generated setter method + * @param param ErrorResponse + */ + public void setErrorResponse(ErrorResponseType param){ + + clearAllSettingTrackers(); + localErrorResponseTracker = param != null; + + this.localErrorResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureResponseTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureResponseTypeChoice", + xmlWriter); + } + + + } + if (localSignatureEnvironmentTracker){ + if (localSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureEnvironment cannot be null!!"); + } + localSignatureEnvironment.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureEnvironment"), + xmlWriter); + } if (localErrorResponseTracker){ + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + localErrorResponse.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localSignatureEnvironmentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureEnvironment")); + + + if (localSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureEnvironment cannot be null!!"); + } + elementList.add(localSignatureEnvironment); + } if (localErrorResponseTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorResponse")); + + + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + elementList.add(localErrorResponse); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureResponseTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureResponseTypeChoice object = + new CreateXMLSignatureResponseTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureEnvironment").equals(reader.getName())){ + + object.setSignatureEnvironment(SignatureEnvironment_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse").equals(reader.getName())){ + + object.setErrorResponse(ErrorResponseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentBaseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localXMLContentTracker = false; + + localLocRefContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for XMLContent + */ + + + protected XMLContentType localXMLContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLContentTracker = false ; + + public boolean isXMLContentSpecified(){ + return localXMLContentTracker; + } + + + + /** + * Auto generated getter method + * @return XMLContentType + */ + public XMLContentType getXMLContent(){ + return localXMLContent; + } + + + + /** + * Auto generated setter method + * @param param XMLContent + */ + public void setXMLContent(XMLContentType param){ + + clearAllSettingTrackers(); + localXMLContentTracker = param != null; + + this.localXMLContent=param; + + + } + + + /** + * field for LocRefContent + */ + + + protected org.apache.axis2.databinding.types.URI localLocRefContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localLocRefContentTracker = false ; + + public boolean isLocRefContentSpecified(){ + return localLocRefContentTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getLocRefContent(){ + return localLocRefContent; + } + + + + /** + * Auto generated setter method + * @param param LocRefContent + */ + public void setLocRefContent(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localLocRefContentTracker = param != null; + + this.localLocRefContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentBaseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentBaseType", + xmlWriter); + } + + + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localXMLContentTracker){ + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + } if (localLocRefContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localXMLContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + } if (localLocRefContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentBaseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentBaseType object = + new ContentBaseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentBaseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentBaseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureMethod", + "ns1"); + + + + /** + * field for SignatureMethod + */ + + + protected SignatureMethodType localSignatureMethod ; + + + /** + * Auto generated getter method + * @return SignatureMethodType + */ + public SignatureMethodType getSignatureMethod(){ + return localSignatureMethod; + } + + + + /** + * Auto generated setter method + * @param param SignatureMethod + */ + public void setSignatureMethod(SignatureMethodType param){ + + this.localSignatureMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureMethod==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureMethod cannot be null!"); + } + localSignatureMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureMethod object = + new SignatureMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureMethod").equals(reader.getName())){ + + object.setSignatureMethod(SignatureMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSDataObjectRequiredMetaType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSDataObjectRequiredMetaType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MetaInfo + */ + + + protected MetaInfoType localMetaInfo ; + + + /** + * Auto generated getter method + * @return MetaInfoType + */ + public MetaInfoType getMetaInfo(){ + return localMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param MetaInfo + */ + public void setMetaInfo(MetaInfoType param){ + + this.localMetaInfo=param; + + + } + + + /** + * field for Content + */ + + + protected CMSContentBaseType localContent ; + + + /** + * Auto generated getter method + * @return CMSContentBaseType + */ + public CMSContentBaseType getContent(){ + return localContent; + } + + + + /** + * Auto generated setter method + * @param param Content + */ + public void setContent(CMSContentBaseType param){ + + this.localContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSDataObjectRequiredMetaType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSDataObjectRequiredMetaType", + xmlWriter); + } + + + } + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSDataObjectRequiredMetaType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSDataObjectRequiredMetaType object = + new CMSDataObjectRequiredMetaType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSDataObjectRequiredMetaType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSDataObjectRequiredMetaType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(CMSContentBaseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyInfo + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "KeyInfo", + "ns1"); + + + + /** + * field for KeyInfo + */ + + + protected KeyInfoType localKeyInfo ; + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getKeyInfo(){ + return localKeyInfo; + } + + + + /** + * Auto generated setter method + * @param param KeyInfo + */ + public void setKeyInfo(KeyInfoType param){ + + this.localKeyInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localKeyInfo==null){ + throw new org.apache.axis2.databinding.ADBException("KeyInfo cannot be null!"); + } + localKeyInfo.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localKeyInfo.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyInfo parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyInfo object = + new KeyInfo(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyInfo").equals(reader.getName())){ + + object.setKeyInfo(KeyInfoType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509DataTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509DataTypeSequence + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for X509DataTypeChoice_type0 + */ + + + protected X509DataTypeChoice_type0 localX509DataTypeChoice_type0 ; + + + /** + * Auto generated getter method + * @return X509DataTypeChoice_type0 + */ + public X509DataTypeChoice_type0 getX509DataTypeChoice_type0(){ + return localX509DataTypeChoice_type0; + } + + + + /** + * Auto generated setter method + * @param param X509DataTypeChoice_type0 + */ + public void setX509DataTypeChoice_type0(X509DataTypeChoice_type0 param){ + + this.localX509DataTypeChoice_type0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509DataTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509DataTypeSequence", + xmlWriter); + } + + + } + + if (localX509DataTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("X509DataTypeChoice_type0 cannot be null!!"); + } + localX509DataTypeChoice_type0.serialize(null,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509DataTypeChoice_type0")); + + + if (localX509DataTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("X509DataTypeChoice_type0 cannot be null!!"); + } + elementList.add(localX509DataTypeChoice_type0); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509DataTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509DataTypeSequence object = + new X509DataTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + object.setX509DataTypeChoice_type0(X509DataTypeChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ObjectTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ObjectTypeSequence + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ObjectTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ObjectTypeSequence", + xmlWriter); + } + + + } + + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ObjectTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ObjectTypeSequence object = + new ObjectTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DigestMethod", + "ns1"); + + + + /** + * field for DigestMethod + */ + + + protected DigestMethodType localDigestMethod ; + + + /** + * Auto generated getter method + * @return DigestMethodType + */ + public DigestMethodType getDigestMethod(){ + return localDigestMethod; + } + + + + /** + * Auto generated setter method + * @param param DigestMethod + */ + public void setDigestMethod(DigestMethodType param){ + + this.localDigestMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!"); + } + localDigestMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localDigestMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestMethod object = + new DigestMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod").equals(reader.getName())){ + + object.setDigestMethod(DigestMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ReferencesCheckResultInfoType extends AnyChildrenType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ReferencesCheckResultInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for FailedReference + * This was an Array! + */ + + + protected org.apache.axis2.databinding.types.PositiveInteger[] localFailedReference ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localFailedReferenceTracker = false ; + + public boolean isFailedReferenceSpecified(){ + return localFailedReferenceTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.PositiveInteger[] + */ + public org.apache.axis2.databinding.types.PositiveInteger[] getFailedReference(){ + return localFailedReference; + } + + + + + + + /** + * validate the array for FailedReference + */ + protected void validateFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + } + + + /** + * Auto generated setter method + * @param param FailedReference + */ + public void setFailedReference(org.apache.axis2.databinding.types.PositiveInteger[] param){ + + validateFailedReference(param); + + localFailedReferenceTracker = param != null; + + this.localFailedReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axis2.databinding.types.PositiveInteger + */ + public void addFailedReference(org.apache.axis2.databinding.types.PositiveInteger param){ + if (localFailedReference == null){ + localFailedReference = new org.apache.axis2.databinding.types.PositiveInteger[]{}; + } + + + //update the setting tracker + localFailedReferenceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localFailedReference); + list.add(param); + this.localFailedReference = + (org.apache.axis2.databinding.types.PositiveInteger[])list.toArray( + new org.apache.axis2.databinding.types.PositiveInteger[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ReferencesCheckResultInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ReferencesCheckResultInfoType", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null) { + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + + writeStartElement(null, namespace, "FailedReference", xmlWriter); + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + + xmlWriter.writeEndElement(); + + } else { + + // we have to do nothing since minOccurs is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localFailedReferenceTracker){ + if (localFailedReference!=null){ + for (int i = 0;i < localFailedReference.length;i++){ + + if (localFailedReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "FailedReference")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localFailedReference[i])); + } else { + + // have to do nothing + + } + + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("FailedReference cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ReferencesCheckResultInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ReferencesCheckResultInfoType object = + new ReferencesCheckResultInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ReferencesCheckResultInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ReferencesCheckResultInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(reader.getElementText()); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // Ensure we are at the EndElement + while (!reader.isEndElement()){ + reader.next(); + } + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FailedReference").equals(reader.getName())){ + list2.add(reader.getElementText()); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setFailedReference((org.apache.axis2.databinding.types.PositiveInteger[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axis2.databinding.types.PositiveInteger.class,list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class MgmtData + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "MgmtData", + "ns1"); + + + + /** + * field for MgmtData + */ + + + protected java.lang.String localMgmtData ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getMgmtData(){ + return localMgmtData; + } + + + + /** + * Auto generated setter method + * @param param MgmtData + */ + public void setMgmtData(java.lang.String param){ + + this.localMgmtData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = "http://www.w3.org/2000/09/xmldsig#"; + java.lang.String _localName = "MgmtData"; + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":MgmtData", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "MgmtData", + xmlWriter); + } + } + + if (localMgmtData==null){ + + throw new org.apache.axis2.databinding.ADBException("MgmtData cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localMgmtData); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMgmtData) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static MgmtData parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + MgmtData object = + new MgmtData(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","MgmtData").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"MgmtData" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setMgmtData( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObject_type1 extends CMSDataObjectRequiredMetaType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObject_type1 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObject_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObject_type1", + xmlWriter); + } + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject_type1")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObject_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObject_type1 object = + new DataObject_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObject_type1".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObject_type1)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(CMSContentBaseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureResponseTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateCMSSignatureResponseTypeChoice + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localCMSSignatureTracker = false; + + localErrorResponseTracker = false; + + } + + + /** + * field for CMSSignature + */ + + + protected javax.activation.DataHandler localCMSSignature ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCMSSignatureTracker = false ; + + public boolean isCMSSignatureSpecified(){ + return localCMSSignatureTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getCMSSignature(){ + return localCMSSignature; + } + + + + /** + * Auto generated setter method + * @param param CMSSignature + */ + public void setCMSSignature(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localCMSSignatureTracker = param != null; + + this.localCMSSignature=param; + + + } + + + /** + * field for ErrorResponse + */ + + + protected ErrorResponseType localErrorResponse ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localErrorResponseTracker = false ; + + public boolean isErrorResponseSpecified(){ + return localErrorResponseTracker; + } + + + + /** + * Auto generated getter method + * @return ErrorResponseType + */ + public ErrorResponseType getErrorResponse(){ + return localErrorResponse; + } + + + + /** + * Auto generated setter method + * @param param ErrorResponse + */ + public void setErrorResponse(ErrorResponseType param){ + + clearAllSettingTrackers(); + localErrorResponseTracker = param != null; + + this.localErrorResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureResponseTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureResponseTypeChoice", + xmlWriter); + } + + + } + if (localCMSSignatureTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "CMSSignature", xmlWriter); + + + if (localCMSSignature!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localCMSSignature, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for CMSSignature", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localErrorResponseTracker){ + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + localErrorResponse.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCMSSignatureTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CMSSignature")); + + elementList.add(localCMSSignature); + } if (localErrorResponseTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorResponse")); + + + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!!"); + } + elementList.add(localErrorResponse); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureResponseTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureResponseTypeChoice object = + new CreateCMSSignatureResponseTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CMSSignature").equals(reader.getName())){ + + object.setCMSSignature(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse").equals(reader.getName())){ + + object.setErrorResponse(ErrorResponseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObject_type0 extends ContentOptionalRefType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObject_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObject_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObject_type0", + xmlWriter); + } + + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject_type0")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObject_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObject_type0 object = + new DataObject_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObject_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObject_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSContentBaseType extends ContentOptionalRefType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSContentBaseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * Auto generated getter method + * Overridden from ContentOptionalRefType + * + * @throws RuntimeException + */ + public org.apache.axis2.databinding.types.URI getReference(){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + /** + * Auto generated setter method + * Overridden from ContentOptionalRefType + * + * @param param Reference + * @throws RuntimeException + */ + public void setReference(org.apache.axis2.databinding.types.URI param){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSContentBaseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSContentBaseType", + xmlWriter); + } + + + } + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSContentBaseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSContentBaseType object = + new CMSContentBaseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSContentBaseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSContentBaseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class QualifiedCertificate + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "QualifiedCertificate", + "ns2"); + + + + /** + * field for Source + * This was an Attribute! + */ + + + protected Source_type1 localSource ; + + + /** + * Auto generated getter method + * @return Source_type1 + */ + public Source_type1 getSource(){ + return localSource; + } + + + + /** + * Auto generated setter method + * @param param Source + */ + public void setSource(Source_type1 param){ + + this.localSource=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":QualifiedCertificate", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "QualifiedCertificate", + xmlWriter); + } + + + } + + + if (localSource != null){ + writeAttribute("", + "source", + localSource.toString(), xmlWriter); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add( + new javax.xml.namespace.QName("","source")); + + attribList.add(localSource.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static QualifiedCertificate parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + QualifiedCertificate object = + new QualifiedCertificate(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"QualifiedCertificate".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (QualifiedCertificate)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "source" + java.lang.String tempAttribSource = + + reader.getAttributeValue(null,"source"); + + if (tempAttribSource!=null){ + java.lang.String content = tempAttribSource; + + object.setSource( + Source_type1.Factory.fromString(reader,tempAttribSource)); + + } else { + + } + handledAttributes.add("source"); + + + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignaturePropertiesType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignaturePropertiesType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SignatureProperty + * This was an Array! + */ + + + protected SignaturePropertyType[] localSignatureProperty ; + + + /** + * Auto generated getter method + * @return SignaturePropertyType[] + */ + public SignaturePropertyType[] getSignatureProperty(){ + return localSignatureProperty; + } + + + + + + + /** + * validate the array for SignatureProperty + */ + protected void validateSignatureProperty(SignaturePropertyType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SignatureProperty + */ + public void setSignatureProperty(SignaturePropertyType[] param){ + + validateSignatureProperty(param); + + + this.localSignatureProperty=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SignaturePropertyType + */ + public void addSignatureProperty(SignaturePropertyType param){ + if (localSignatureProperty == null){ + localSignatureProperty = new SignaturePropertyType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSignatureProperty); + list.add(param); + this.localSignatureProperty = + (SignaturePropertyType[])list.toArray( + new SignaturePropertyType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignaturePropertiesType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignaturePropertiesType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localSignatureProperty!=null){ + for (int i = 0;i < localSignatureProperty.length;i++){ + if (localSignatureProperty[i] != null){ + localSignatureProperty[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localSignatureProperty!=null) { + for (int i = 0;i < localSignatureProperty.length;i++){ + + if (localSignatureProperty[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignatureProperty")); + elementList.add(localSignatureProperty[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignaturePropertiesType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignaturePropertiesType object = + new SignaturePropertiesType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignaturePropertiesType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignaturePropertiesType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(SignaturePropertyType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty").equals(reader.getName())){ + list1.add(SignaturePropertyType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSignatureProperty((SignaturePropertyType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SignaturePropertyType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatoriesType extends org.apache.axis2.databinding.types.Union + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatoriesType", + "ns2"); + + + + + public void setObject(java.lang.Object object){ + + if (object instanceof AllSignatoriesType){ + this.localObject = object; + + } else { + throw new java.lang.RuntimeException("Invalid object type"); + } + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + writeStartElement(null, parentQName.getNamespaceURI(), parentQName.getLocalPart(), xmlWriter); + + + if (localObject instanceof AllSignatoriesType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":AllSignatoriesType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "AllSignatoriesType", + xmlWriter); + } + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString((AllSignatoriesType)localObject)); + + } else { + throw new org.apache.axis2.databinding.ADBException("Invalid object type"); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + localObject.toString() + }, + null); + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + public static SignatoriesType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String namespaceURI, + java.lang.String type) throws org.apache.axis2.databinding.ADBException { + + SignatoriesType object = null; + try { + if ("http://www.w3.org/2001/XMLSchema".equals(namespaceURI)) { + object = new SignatoriesType(); + object.setObject(xmlStreamReader, namespaceURI, type); + } else { + object = new SignatoriesType(); + object.setObject(ExtensionMapper.getTypeObject(namespaceURI, type, xmlStreamReader)); + } + return object; + } catch (java.lang.Exception e) { + throw new org.apache.axis2.databinding.ADBException("Error in parsing value"); + } + } + + public static SignatoriesType fromString(java.lang.String value, + java.lang.String namespaceURI){ + SignatoriesType object = new SignatoriesType(); + boolean isValueSet = false; + + // we have to set the object with the first matching type. + if (!isValueSet) { + + try { + object.setObject(AllSignatoriesType.Factory.fromString(value, namespaceURI)); + isValueSet = true; + } catch (java.lang.Exception e) { + } + + } + + return object; + } + + public static SignatoriesType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return SignatoriesType.Factory.fromString(content,namespaceUri); + } else { + return SignatoriesType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatoriesType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatoriesType object = + new SignatoriesType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + object = SignatoriesType.Factory.fromString(reader,nsUri,type); + + + } + + } else { + // i.e this is an union type with out specific xsi:type + java.lang.String content = reader.getElementText(); + if (content.indexOf(":") > -1){ + // i.e. this could be a qname + prefix = content.substring(0,content.indexOf(":")); + namespaceuri = reader.getNamespaceContext().getNamespaceURI(prefix); + object = SignatoriesType.Factory.fromString(content,namespaceuri); + } else { + object = SignatoriesType.Factory.fromString(content,""); + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureRequest + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyXMLSignatureRequest", + "ns2"); + + + + /** + * field for VerifyXMLSignatureRequest + */ + + + protected VerifyXMLSignatureRequestType localVerifyXMLSignatureRequest ; + + + /** + * Auto generated getter method + * @return VerifyXMLSignatureRequestType + */ + public VerifyXMLSignatureRequestType getVerifyXMLSignatureRequest(){ + return localVerifyXMLSignatureRequest; + } + + + + /** + * Auto generated setter method + * @param param VerifyXMLSignatureRequest + */ + public void setVerifyXMLSignatureRequest(VerifyXMLSignatureRequestType param){ + + this.localVerifyXMLSignatureRequest=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyXMLSignatureRequest==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureRequest cannot be null!"); + } + localVerifyXMLSignatureRequest.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyXMLSignatureRequest.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureRequest object = + new VerifyXMLSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyXMLSignatureRequest").equals(reader.getName())){ + + object.setVerifyXMLSignatureRequest(VerifyXMLSignatureRequestType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DSAKeyValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for DSAKeyValueTypeSequence_type0 + */ + + + protected DSAKeyValueTypeSequence_type0 localDSAKeyValueTypeSequence_type0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDSAKeyValueTypeSequence_type0Tracker = false ; + + public boolean isDSAKeyValueTypeSequence_type0Specified(){ + return localDSAKeyValueTypeSequence_type0Tracker; + } + + + + /** + * Auto generated getter method + * @return DSAKeyValueTypeSequence_type0 + */ + public DSAKeyValueTypeSequence_type0 getDSAKeyValueTypeSequence_type0(){ + return localDSAKeyValueTypeSequence_type0; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValueTypeSequence_type0 + */ + public void setDSAKeyValueTypeSequence_type0(DSAKeyValueTypeSequence_type0 param){ + localDSAKeyValueTypeSequence_type0Tracker = param != null; + + this.localDSAKeyValueTypeSequence_type0=param; + + + } + + + /** + * field for G + */ + + + protected CryptoBinary localG ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localGTracker = false ; + + public boolean isGSpecified(){ + return localGTracker; + } + + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getG(){ + return localG; + } + + + + /** + * Auto generated setter method + * @param param G + */ + public void setG(CryptoBinary param){ + localGTracker = param != null; + + this.localG=param; + + + } + + + /** + * field for Y + */ + + + protected CryptoBinary localY ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getY(){ + return localY; + } + + + + /** + * Auto generated setter method + * @param param Y + */ + public void setY(CryptoBinary param){ + + this.localY=param; + + + } + + + /** + * field for J + */ + + + protected CryptoBinary localJ ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localJTracker = false ; + + public boolean isJSpecified(){ + return localJTracker; + } + + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getJ(){ + return localJ; + } + + + + /** + * Auto generated setter method + * @param param J + */ + public void setJ(CryptoBinary param){ + localJTracker = param != null; + + this.localJ=param; + + + } + + + /** + * field for DSAKeyValueTypeSequence_type1 + */ + + + protected DSAKeyValueTypeSequence_type1 localDSAKeyValueTypeSequence_type1 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDSAKeyValueTypeSequence_type1Tracker = false ; + + public boolean isDSAKeyValueTypeSequence_type1Specified(){ + return localDSAKeyValueTypeSequence_type1Tracker; + } + + + + /** + * Auto generated getter method + * @return DSAKeyValueTypeSequence_type1 + */ + public DSAKeyValueTypeSequence_type1 getDSAKeyValueTypeSequence_type1(){ + return localDSAKeyValueTypeSequence_type1; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValueTypeSequence_type1 + */ + public void setDSAKeyValueTypeSequence_type1(DSAKeyValueTypeSequence_type1 param){ + localDSAKeyValueTypeSequence_type1Tracker = param != null; + + this.localDSAKeyValueTypeSequence_type1=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DSAKeyValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DSAKeyValueType", + xmlWriter); + } + + + } + if (localDSAKeyValueTypeSequence_type0Tracker){ + if (localDSAKeyValueTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type0 cannot be null!!"); + } + localDSAKeyValueTypeSequence_type0.serialize(null,xmlWriter); + } if (localGTracker){ + if (localG==null){ + throw new org.apache.axis2.databinding.ADBException("G cannot be null!!"); + } + localG.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","G"), + xmlWriter); + } + if (localY==null){ + throw new org.apache.axis2.databinding.ADBException("Y cannot be null!!"); + } + localY.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Y"), + xmlWriter); + if (localJTracker){ + if (localJ==null){ + throw new org.apache.axis2.databinding.ADBException("J cannot be null!!"); + } + localJ.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","J"), + xmlWriter); + } if (localDSAKeyValueTypeSequence_type1Tracker){ + if (localDSAKeyValueTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type1 cannot be null!!"); + } + localDSAKeyValueTypeSequence_type1.serialize(null,xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDSAKeyValueTypeSequence_type0Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValueTypeSequence_type0")); + + + if (localDSAKeyValueTypeSequence_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type0 cannot be null!!"); + } + elementList.add(localDSAKeyValueTypeSequence_type0); + } if (localGTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "G")); + + + if (localG==null){ + throw new org.apache.axis2.databinding.ADBException("G cannot be null!!"); + } + elementList.add(localG); + } + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Y")); + + + if (localY==null){ + throw new org.apache.axis2.databinding.ADBException("Y cannot be null!!"); + } + elementList.add(localY); + if (localJTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "J")); + + + if (localJ==null){ + throw new org.apache.axis2.databinding.ADBException("J cannot be null!!"); + } + elementList.add(localJ); + } if (localDSAKeyValueTypeSequence_type1Tracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValueTypeSequence_type1")); + + + if (localDSAKeyValueTypeSequence_type1==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValueTypeSequence_type1 cannot be null!!"); + } + elementList.add(localDSAKeyValueTypeSequence_type1); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValueType object = + new DSAKeyValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DSAKeyValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DSAKeyValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setDSAKeyValueTypeSequence_type0(DSAKeyValueTypeSequence_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","G").equals(reader.getName())){ + + object.setG(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Y").equals(reader.getName())){ + + object.setY(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","J").equals(reader.getName())){ + + object.setJ(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + object.setDSAKeyValueTypeSequence_type1(DSAKeyValueTypeSequence_type1.Factory.parse(reader)); + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509IssuerSerialType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509IssuerSerialType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for X509IssuerName + */ + + + protected java.lang.String localX509IssuerName ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getX509IssuerName(){ + return localX509IssuerName; + } + + + + /** + * Auto generated setter method + * @param param X509IssuerName + */ + public void setX509IssuerName(java.lang.String param){ + + this.localX509IssuerName=param; + + + } + + + /** + * field for X509SerialNumber + */ + + + protected java.math.BigInteger localX509SerialNumber ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getX509SerialNumber(){ + return localX509SerialNumber; + } + + + + /** + * Auto generated setter method + * @param param X509SerialNumber + */ + public void setX509SerialNumber(java.math.BigInteger param){ + + this.localX509SerialNumber=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509IssuerSerialType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509IssuerSerialType", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509IssuerName", xmlWriter); + + + if (localX509IssuerName==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("X509IssuerName cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localX509IssuerName); + + } + + xmlWriter.writeEndElement(); + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "X509SerialNumber", xmlWriter); + + + if (localX509SerialNumber==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("X509SerialNumber cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509SerialNumber)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509IssuerName")); + + if (localX509IssuerName != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509IssuerName)); + } else { + throw new org.apache.axis2.databinding.ADBException("X509IssuerName cannot be null!!"); + } + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509SerialNumber")); + + if (localX509SerialNumber != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localX509SerialNumber)); + } else { + throw new org.apache.axis2.databinding.ADBException("X509SerialNumber cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509IssuerSerialType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509IssuerSerialType object = + new X509IssuerSerialType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"X509IssuerSerialType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (X509IssuerSerialType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509IssuerName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"X509IssuerName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setX509IssuerName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509SerialNumber").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"X509SerialNumber" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setX509SerialNumber( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignedInfo + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignedInfo", + "ns1"); + + + + /** + * field for SignedInfo + */ + + + protected SignedInfoType localSignedInfo ; + + + /** + * Auto generated getter method + * @return SignedInfoType + */ + public SignedInfoType getSignedInfo(){ + return localSignedInfo; + } + + + + /** + * Auto generated setter method + * @param param SignedInfo + */ + public void setSignedInfo(SignedInfoType param){ + + this.localSignedInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignedInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignedInfo cannot be null!"); + } + localSignedInfo.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignedInfo.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignedInfo parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignedInfo object = + new SignedInfo(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignedInfo").equals(reader.getName())){ + + object.setSignedInfo(SignedInfoType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureRequestTypeChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyXMLSignatureRequestTypeChoice_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localSupplementProfileTracker = false; + + localSupplementProfileIDTracker = false; + + } + + + /** + * field for SupplementProfile + */ + + + protected XMLDataObjectAssociationType localSupplementProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementProfileTracker = false ; + + public boolean isSupplementProfileSpecified(){ + return localSupplementProfileTracker; + } + + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType + */ + public XMLDataObjectAssociationType getSupplementProfile(){ + return localSupplementProfile; + } + + + + /** + * Auto generated setter method + * @param param SupplementProfile + */ + public void setSupplementProfile(XMLDataObjectAssociationType param){ + + clearAllSettingTrackers(); + localSupplementProfileTracker = param != null; + + this.localSupplementProfile=param; + + + } + + + /** + * field for SupplementProfileID + */ + + + protected java.lang.String localSupplementProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementProfileIDTracker = false ; + + public boolean isSupplementProfileIDSpecified(){ + return localSupplementProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getSupplementProfileID(){ + return localSupplementProfileID; + } + + + + /** + * Auto generated setter method + * @param param SupplementProfileID + */ + public void setSupplementProfileID(java.lang.String param){ + + clearAllSettingTrackers(); + localSupplementProfileIDTracker = param != null; + + this.localSupplementProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyXMLSignatureRequestTypeChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyXMLSignatureRequestTypeChoice_type0", + xmlWriter); + } + + + } + if (localSupplementProfileTracker){ + if (localSupplementProfile==null){ + throw new org.apache.axis2.databinding.ADBException("SupplementProfile cannot be null!!"); + } + localSupplementProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfile"), + xmlWriter); + } if (localSupplementProfileIDTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "SupplementProfileID", xmlWriter); + + + if (localSupplementProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("SupplementProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localSupplementProfileID); + + } + + xmlWriter.writeEndElement(); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localSupplementProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SupplementProfile")); + + + if (localSupplementProfile==null){ + throw new org.apache.axis2.databinding.ADBException("SupplementProfile cannot be null!!"); + } + elementList.add(localSupplementProfile); + } if (localSupplementProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SupplementProfileID")); + + if (localSupplementProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSupplementProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("SupplementProfileID cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureRequestTypeChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureRequestTypeChoice_type0 object = + new VerifyXMLSignatureRequestTypeChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfile").equals(reader.getName())){ + + object.setSupplementProfile(XMLDataObjectAssociationType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"SupplementProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setSupplementProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Object + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Object", + "ns1"); + + + + /** + * field for Object + */ + + + protected ObjectType localObject ; + + + /** + * Auto generated getter method + * @return ObjectType + */ + public ObjectType getObject(){ + return localObject; + } + + + + /** + * Auto generated setter method + * @param param Object + */ + public void setObject(ObjectType param){ + + this.localObject=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localObject==null){ + throw new org.apache.axis2.databinding.ADBException("Object cannot be null!"); + } + localObject.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localObject.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Object parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Object object = + new Object(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Object").equals(reader.getName())){ + + object.setObject(ObjectType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = KeyValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localDSAKeyValueTracker = false; + + localRSAKeyValueTracker = false; + + localExtraElementTracker = false; + + } + + + /** + * field for DSAKeyValue + */ + + + protected DSAKeyValueType localDSAKeyValue ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDSAKeyValueTracker = false ; + + public boolean isDSAKeyValueSpecified(){ + return localDSAKeyValueTracker; + } + + + + /** + * Auto generated getter method + * @return DSAKeyValueType + */ + public DSAKeyValueType getDSAKeyValue(){ + return localDSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValue + */ + public void setDSAKeyValue(DSAKeyValueType param){ + + clearAllSettingTrackers(); + localDSAKeyValueTracker = param != null; + + this.localDSAKeyValue=param; + + + } + + + /** + * field for RSAKeyValue + */ + + + protected RSAKeyValueType localRSAKeyValue ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localRSAKeyValueTracker = false ; + + public boolean isRSAKeyValueSpecified(){ + return localRSAKeyValueTracker; + } + + + + /** + * Auto generated getter method + * @return RSAKeyValueType + */ + public RSAKeyValueType getRSAKeyValue(){ + return localRSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param RSAKeyValue + */ + public void setRSAKeyValue(RSAKeyValueType param){ + + clearAllSettingTrackers(); + localRSAKeyValueTracker = param != null; + + this.localRSAKeyValue=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyValueType", + xmlWriter); + } + + + } + if (localDSAKeyValueTracker){ + if (localDSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValue cannot be null!!"); + } + localDSAKeyValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DSAKeyValue"), + xmlWriter); + } if (localRSAKeyValueTracker){ + if (localRSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("RSAKeyValue cannot be null!!"); + } + localRSAKeyValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RSAKeyValue"), + xmlWriter); + } if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDSAKeyValueTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValue")); + + + if (localDSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValue cannot be null!!"); + } + elementList.add(localDSAKeyValue); + } if (localRSAKeyValueTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "RSAKeyValue")); + + + if (localRSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("RSAKeyValue cannot be null!!"); + } + elementList.add(localRSAKeyValue); + } if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyValueType object = + new KeyValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"KeyValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (KeyValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DSAKeyValue").equals(reader.getName())){ + + object.setDSAKeyValue(DSAKeyValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RSAKeyValue").equals(reader.getName())){ + + object.setRSAKeyValue(RSAKeyValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname3 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname3); + object.setExtraElement(builder3.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyCMSSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DateTime + */ + + + protected java.util.Calendar localDateTime ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDateTimeTracker = false ; + + public boolean isDateTimeSpecified(){ + return localDateTimeTracker; + } + + + + /** + * Auto generated getter method + * @return java.util.Calendar + */ + public java.util.Calendar getDateTime(){ + return localDateTime; + } + + + + /** + * Auto generated setter method + * @param param DateTime + */ + public void setDateTime(java.util.Calendar param){ + localDateTimeTracker = param != null; + + this.localDateTime=param; + + + } + + + /** + * field for CMSSignature + */ + + + protected javax.activation.DataHandler localCMSSignature ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getCMSSignature(){ + return localCMSSignature; + } + + + + /** + * Auto generated setter method + * @param param CMSSignature + */ + public void setCMSSignature(javax.activation.DataHandler param){ + + this.localCMSSignature=param; + + + } + + + /** + * field for DataObject + */ + + + protected CMSDataObjectOptionalMetaType localDataObject ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDataObjectTracker = false ; + + public boolean isDataObjectSpecified(){ + return localDataObjectTracker; + } + + + + /** + * Auto generated getter method + * @return CMSDataObjectOptionalMetaType + */ + public CMSDataObjectOptionalMetaType getDataObject(){ + return localDataObject; + } + + + + /** + * Auto generated setter method + * @param param DataObject + */ + public void setDataObject(CMSDataObjectOptionalMetaType param){ + localDataObjectTracker = param != null; + + this.localDataObject=param; + + + } + + + /** + * field for TrustProfileID + */ + + + protected org.apache.axis2.databinding.types.Token localTrustProfileID ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getTrustProfileID(){ + return localTrustProfileID; + } + + + + /** + * Auto generated setter method + * @param param TrustProfileID + */ + public void setTrustProfileID(org.apache.axis2.databinding.types.Token param){ + + this.localTrustProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureRequestType", + xmlWriter); + } + + + } + if (localDateTimeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "DateTime", xmlWriter); + + + if (localDateTime==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + + } + + xmlWriter.writeEndElement(); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "CMSSignature", xmlWriter); + + + if (localCMSSignature!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localCMSSignature, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for CMSSignature", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localDataObjectTracker){ + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "TrustProfileID", xmlWriter); + + + if (localTrustProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDateTimeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DateTime")); + + if (localDateTime != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + } else { + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CMSSignature")); + + elementList.add(localCMSSignature); + if (localDataObjectTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TrustProfileID")); + + if (localTrustProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureRequestType object = + new VerifyCMSSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyCMSSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyCMSSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DateTime").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DateTime" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDateTime( + org.apache.axis2.databinding.utils.ConverterUtil.convertToDateTime(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CMSSignature").equals(reader.getName())){ + + object.setCMSSignature(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(CMSDataObjectOptionalMetaType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TrustProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"TrustProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setTrustProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentRequiredRefType extends ContentOptionalRefType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentRequiredRefType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localXMLContentTracker = false; + + localLocRefContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for XMLContent + */ + + + protected XMLContentType localXMLContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLContentTracker = false ; + + public boolean isXMLContentSpecified(){ + return localXMLContentTracker; + } + + + + /** + * Auto generated getter method + * @return XMLContentType + */ + public XMLContentType getXMLContent(){ + return localXMLContent; + } + + + + /** + * Auto generated setter method + * @param param XMLContent + */ + public void setXMLContent(XMLContentType param){ + + clearAllSettingTrackers(); + localXMLContentTracker = param != null; + + this.localXMLContent=param; + + + } + + + /** + * field for LocRefContent + */ + + + protected org.apache.axis2.databinding.types.URI localLocRefContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localLocRefContentTracker = false ; + + public boolean isLocRefContentSpecified(){ + return localLocRefContentTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getLocRefContent(){ + return localLocRefContent; + } + + + + /** + * Auto generated setter method + * @param param LocRefContent + */ + public void setLocRefContent(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localLocRefContentTracker = param != null; + + this.localLocRefContent=param; + + + } + + + /** + * field for Reference + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localReference ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localReferenceTracker = false ; + + public boolean isReferenceSpecified(){ + return localReferenceTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getReference(){ + return localReference; + } + + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localReferenceTracker = param != null; + + this.localReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentRequiredRefType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentRequiredRefType", + xmlWriter); + } + + + } + + if (localReference != null){ + + writeAttribute("", + "Reference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localReference is null"); + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localXMLContentTracker){ + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + } if (localLocRefContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localXMLContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + } if (localLocRefContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Reference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentRequiredRefType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentRequiredRefType object = + new ContentRequiredRefType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentRequiredRefType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentRequiredRefType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Reference" + java.lang.String tempAttribReference = + + reader.getAttributeValue(null,"Reference"); + + if (tempAttribReference!=null){ + java.lang.String content = tempAttribReference; + + object.setReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribReference)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Reference is missing"); + + } + handledAttributes.add("Reference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureInfo_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateSignatureEnvironment + */ + + + protected ContentOptionalRefType localCreateSignatureEnvironment ; + + + /** + * Auto generated getter method + * @return ContentOptionalRefType + */ + public ContentOptionalRefType getCreateSignatureEnvironment(){ + return localCreateSignatureEnvironment; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironment + */ + public void setCreateSignatureEnvironment(ContentOptionalRefType param){ + + this.localCreateSignatureEnvironment=param; + + + } + + + /** + * field for CreateSignatureInfoChoice_type0 + */ + + + protected CreateSignatureInfoChoice_type0 localCreateSignatureInfoChoice_type0 ; + + + /** + * Auto generated getter method + * @return CreateSignatureInfoChoice_type0 + */ + public CreateSignatureInfoChoice_type0 getCreateSignatureInfoChoice_type0(){ + return localCreateSignatureInfoChoice_type0; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureInfoChoice_type0 + */ + public void setCreateSignatureInfoChoice_type0(CreateSignatureInfoChoice_type0 param){ + + this.localCreateSignatureInfoChoice_type0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureInfo_type0", + xmlWriter); + } + + + } + + if (localCreateSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironment cannot be null!!"); + } + localCreateSignatureEnvironment.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironment"), + xmlWriter); + + if (localCreateSignatureInfoChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfoChoice_type0 cannot be null!!"); + } + localCreateSignatureInfoChoice_type0.serialize(null,xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironment")); + + + if (localCreateSignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironment cannot be null!!"); + } + elementList.add(localCreateSignatureEnvironment); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureInfoChoice_type0")); + + + if (localCreateSignatureInfoChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfoChoice_type0 cannot be null!!"); + } + elementList.add(localCreateSignatureInfoChoice_type0); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureInfo_type0 object = + new CreateSignatureInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateSignatureInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateSignatureInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironment").equals(reader.getName())){ + + object.setCreateSignatureEnvironment(ContentOptionalRefType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + object.setCreateSignatureInfoChoice_type0(CreateSignatureInfoChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509Data + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "X509Data", + "ns1"); + + + + /** + * field for X509Data + */ + + + protected X509DataType localX509Data ; + + + /** + * Auto generated getter method + * @return X509DataType + */ + public X509DataType getX509Data(){ + return localX509Data; + } + + + + /** + * Auto generated setter method + * @param param X509Data + */ + public void setX509Data(X509DataType param){ + + this.localX509Data=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localX509Data==null){ + throw new org.apache.axis2.databinding.ADBException("X509Data cannot be null!"); + } + localX509Data.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localX509Data.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509Data parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509Data object = + new X509Data(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","X509Data").equals(reader.getName())){ + + object.setX509Data(X509DataType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfoTypeChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfoTypeChoice_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localCreateTransformsInfoProfileTracker = false; + + localCreateTransformsInfoProfileIDTracker = false; + + } + + + /** + * field for CreateTransformsInfoProfile + */ + + + protected CreateTransformsInfoProfile_type0 localCreateTransformsInfoProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateTransformsInfoProfileTracker = false ; + + public boolean isCreateTransformsInfoProfileSpecified(){ + return localCreateTransformsInfoProfileTracker; + } + + + + /** + * Auto generated getter method + * @return CreateTransformsInfoProfile_type0 + */ + public CreateTransformsInfoProfile_type0 getCreateTransformsInfoProfile(){ + return localCreateTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfoProfile + */ + public void setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0 param){ + + clearAllSettingTrackers(); + localCreateTransformsInfoProfileTracker = param != null; + + this.localCreateTransformsInfoProfile=param; + + + } + + + /** + * field for CreateTransformsInfoProfileID + */ + + + protected ProfileIdentifierType localCreateTransformsInfoProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateTransformsInfoProfileIDTracker = false ; + + public boolean isCreateTransformsInfoProfileIDSpecified(){ + return localCreateTransformsInfoProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return ProfileIdentifierType + */ + public ProfileIdentifierType getCreateTransformsInfoProfileID(){ + return localCreateTransformsInfoProfileID; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfoProfileID + */ + public void setCreateTransformsInfoProfileID(ProfileIdentifierType param){ + + clearAllSettingTrackers(); + localCreateTransformsInfoProfileIDTracker = param != null; + + this.localCreateTransformsInfoProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfoTypeChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfoTypeChoice_type0", + xmlWriter); + } + + + } + if (localCreateTransformsInfoProfileTracker){ + if (localCreateTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfile cannot be null!!"); + } + localCreateTransformsInfoProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfile"), + xmlWriter); + } if (localCreateTransformsInfoProfileIDTracker){ + if (localCreateTransformsInfoProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfileID cannot be null!!"); + } + localCreateTransformsInfoProfileID.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfileID"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCreateTransformsInfoProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfoProfile")); + + + if (localCreateTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfile cannot be null!!"); + } + elementList.add(localCreateTransformsInfoProfile); + } if (localCreateTransformsInfoProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfoProfileID")); + + + if (localCreateTransformsInfoProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfileID cannot be null!!"); + } + elementList.add(localCreateTransformsInfoProfileID); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfoTypeChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfoTypeChoice_type0 object = + new DataObjectInfoTypeChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfile").equals(reader.getName())){ + + object.setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfileID").equals(reader.getName())){ + + object.setCreateTransformsInfoProfileID(ProfileIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureInfoChoice_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureInfoChoice_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localCreateSignatureEnvironmentProfileTracker = false; + + localCreateSignatureEnvironmentProfileIDTracker = false; + + } + + + /** + * field for CreateSignatureEnvironmentProfile + */ + + + protected CreateSignatureEnvironmentProfile_type0 localCreateSignatureEnvironmentProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateSignatureEnvironmentProfileTracker = false ; + + public boolean isCreateSignatureEnvironmentProfileSpecified(){ + return localCreateSignatureEnvironmentProfileTracker; + } + + + + /** + * Auto generated getter method + * @return CreateSignatureEnvironmentProfile_type0 + */ + public CreateSignatureEnvironmentProfile_type0 getCreateSignatureEnvironmentProfile(){ + return localCreateSignatureEnvironmentProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironmentProfile + */ + public void setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0 param){ + + clearAllSettingTrackers(); + localCreateSignatureEnvironmentProfileTracker = param != null; + + this.localCreateSignatureEnvironmentProfile=param; + + + } + + + /** + * field for CreateSignatureEnvironmentProfileID + */ + + + protected ProfileIdentifierType localCreateSignatureEnvironmentProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateSignatureEnvironmentProfileIDTracker = false ; + + public boolean isCreateSignatureEnvironmentProfileIDSpecified(){ + return localCreateSignatureEnvironmentProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return ProfileIdentifierType + */ + public ProfileIdentifierType getCreateSignatureEnvironmentProfileID(){ + return localCreateSignatureEnvironmentProfileID; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironmentProfileID + */ + public void setCreateSignatureEnvironmentProfileID(ProfileIdentifierType param){ + + clearAllSettingTrackers(); + localCreateSignatureEnvironmentProfileIDTracker = param != null; + + this.localCreateSignatureEnvironmentProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureInfoChoice_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureInfoChoice_type0", + xmlWriter); + } + + + } + if (localCreateSignatureEnvironmentProfileTracker){ + if (localCreateSignatureEnvironmentProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfile cannot be null!!"); + } + localCreateSignatureEnvironmentProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfile"), + xmlWriter); + } if (localCreateSignatureEnvironmentProfileIDTracker){ + if (localCreateSignatureEnvironmentProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfileID cannot be null!!"); + } + localCreateSignatureEnvironmentProfileID.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfileID"), + xmlWriter); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCreateSignatureEnvironmentProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironmentProfile")); + + + if (localCreateSignatureEnvironmentProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfile cannot be null!!"); + } + elementList.add(localCreateSignatureEnvironmentProfile); + } if (localCreateSignatureEnvironmentProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironmentProfileID")); + + + if (localCreateSignatureEnvironmentProfileID==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfileID cannot be null!!"); + } + elementList.add(localCreateSignatureEnvironmentProfileID); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureInfoChoice_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureInfoChoice_type0 object = + new CreateSignatureInfoChoice_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfile").equals(reader.getName())){ + + object.setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfileID").equals(reader.getName())){ + + object.setCreateSignatureEnvironmentProfileID(ProfileIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsInfoProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsInfoProfile", + "ns2"); + + + + /** + * field for VerifyTransformsInfoProfile + */ + + + protected VerifyTransformsInfoProfile_type0 localVerifyTransformsInfoProfile ; + + + /** + * Auto generated getter method + * @return VerifyTransformsInfoProfile_type0 + */ + public VerifyTransformsInfoProfile_type0 getVerifyTransformsInfoProfile(){ + return localVerifyTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param VerifyTransformsInfoProfile + */ + public void setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0 param){ + + this.localVerifyTransformsInfoProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfile cannot be null!"); + } + localVerifyTransformsInfoProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyTransformsInfoProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsInfoProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsInfoProfile object = + new VerifyTransformsInfoProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfile").equals(reader.getName())){ + + object.setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CryptoBinary + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "CryptoBinary", + "ns1"); + + + + /** + * field for CryptoBinary + */ + + + protected javax.activation.DataHandler localCryptoBinary ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getCryptoBinary(){ + return localCryptoBinary; + } + + + + /** + * Auto generated setter method + * @param param CryptoBinary + */ + public void setCryptoBinary(javax.activation.DataHandler param){ + + this.localCryptoBinary=param; + + + } + + + public java.lang.String toString(){ + + return localCryptoBinary.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CryptoBinary", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CryptoBinary", + xmlWriter); + } + } + + if (localCryptoBinary==null){ + + throw new org.apache.axis2.databinding.ADBException("CryptoBinary cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCryptoBinary)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCryptoBinary) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static CryptoBinary fromString(java.lang.String value, + java.lang.String namespaceURI){ + CryptoBinary returnValue = new CryptoBinary(); + + returnValue.setCryptoBinary( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(value)); + + + return returnValue; + } + + public static CryptoBinary fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return CryptoBinary.Factory.fromString(content,namespaceUri); + } else { + return CryptoBinary.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CryptoBinary parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CryptoBinary object = + new CryptoBinary(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"CryptoBinary" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCryptoBinary( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifySignatureInfo_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifySignatureInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for VerifySignatureEnvironment + */ + + + protected ContentOptionalRefType localVerifySignatureEnvironment ; + + + /** + * Auto generated getter method + * @return ContentOptionalRefType + */ + public ContentOptionalRefType getVerifySignatureEnvironment(){ + return localVerifySignatureEnvironment; + } + + + + /** + * Auto generated setter method + * @param param VerifySignatureEnvironment + */ + public void setVerifySignatureEnvironment(ContentOptionalRefType param){ + + this.localVerifySignatureEnvironment=param; + + + } + + + /** + * field for VerifySignatureLocation + */ + + + protected org.apache.axis2.databinding.types.Token localVerifySignatureLocation ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getVerifySignatureLocation(){ + return localVerifySignatureLocation; + } + + + + /** + * Auto generated setter method + * @param param VerifySignatureLocation + */ + public void setVerifySignatureLocation(org.apache.axis2.databinding.types.Token param){ + + this.localVerifySignatureLocation=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifySignatureInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifySignatureInfo_type0", + xmlWriter); + } + + + } + + if (localVerifySignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureEnvironment cannot be null!!"); + } + localVerifySignatureEnvironment.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureEnvironment"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "VerifySignatureLocation", xmlWriter); + + + if (localVerifySignatureLocation==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("VerifySignatureLocation cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localVerifySignatureLocation)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifySignatureEnvironment")); + + + if (localVerifySignatureEnvironment==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureEnvironment cannot be null!!"); + } + elementList.add(localVerifySignatureEnvironment); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifySignatureLocation")); + + if (localVerifySignatureLocation != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localVerifySignatureLocation)); + } else { + throw new org.apache.axis2.databinding.ADBException("VerifySignatureLocation cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifySignatureInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifySignatureInfo_type0 object = + new VerifySignatureInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifySignatureInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifySignatureInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureEnvironment").equals(reader.getName())){ + + object.setVerifySignatureEnvironment(ContentOptionalRefType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureLocation").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"VerifySignatureLocation" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setVerifySignatureLocation( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SPKIDataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SPKIDataType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SPKIDataTypeSequence + * This was an Array! + */ + + + protected SPKIDataTypeSequence[] localSPKIDataTypeSequence ; + + + /** + * Auto generated getter method + * @return SPKIDataTypeSequence[] + */ + public SPKIDataTypeSequence[] getSPKIDataTypeSequence(){ + return localSPKIDataTypeSequence; + } + + + + + + + /** + * validate the array for SPKIDataTypeSequence + */ + protected void validateSPKIDataTypeSequence(SPKIDataTypeSequence[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SPKIDataTypeSequence + */ + public void setSPKIDataTypeSequence(SPKIDataTypeSequence[] param){ + + validateSPKIDataTypeSequence(param); + + + this.localSPKIDataTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SPKIDataTypeSequence + */ + public void addSPKIDataTypeSequence(SPKIDataTypeSequence param){ + if (localSPKIDataTypeSequence == null){ + localSPKIDataTypeSequence = new SPKIDataTypeSequence[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSPKIDataTypeSequence); + list.add(param); + this.localSPKIDataTypeSequence = + (SPKIDataTypeSequence[])list.toArray( + new SPKIDataTypeSequence[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SPKIDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SPKIDataType", + xmlWriter); + } + + + } + + + if (localSPKIDataTypeSequence!=null){ + for (int i = 0;i < localSPKIDataTypeSequence.length;i++){ + if (localSPKIDataTypeSequence[i] != null){ + localSPKIDataTypeSequence[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localSPKIDataTypeSequence!=null) { + for (int i = 0;i < localSPKIDataTypeSequence.length;i++){ + + if (localSPKIDataTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SPKIDataTypeSequence")); + elementList.add(localSPKIDataTypeSequence[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SPKIDataTypeSequence cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SPKIDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SPKIDataType object = + new SPKIDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SPKIDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SPKIDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(SPKIDataTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(SPKIDataTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setSPKIDataTypeSequence((SPKIDataTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SPKIDataTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformTypeChoice + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localExtraElementTracker = false; + + localXPathTracker = false; + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + /** + * field for XPath + */ + + + protected java.lang.String localXPath ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXPathTracker = false ; + + public boolean isXPathSpecified(){ + return localXPathTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getXPath(){ + return localXPath; + } + + + + /** + * Auto generated setter method + * @param param XPath + */ + public void setXPath(java.lang.String param){ + + clearAllSettingTrackers(); + localXPathTracker = param != null; + + this.localXPath=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformTypeChoice", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localXPathTracker){ + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "XPath", xmlWriter); + + + if (localXPath==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("XPath cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localXPath); + + } + + xmlWriter.writeEndElement(); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } if (localXPathTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "XPath")); + + if (localXPath != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localXPath)); + } else { + throw new org.apache.axis2.databinding.ADBException("XPath cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformTypeChoice object = + new TransformTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","XPath").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"XPath" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setXPath( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CanonicalizationMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CanonicalizationMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CanonicalizationMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CanonicalizationMethodType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CanonicalizationMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CanonicalizationMethodType object = + new CanonicalizationMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CanonicalizationMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CanonicalizationMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureRequest extends CreateXMLSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateXMLSignatureRequest", + "ns2"); + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureRequest", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureRequest", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateXMLSignatureRequest")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureRequest object = + new CreateXMLSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateXMLSignatureRequest".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateXMLSignatureRequest)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type0.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureEnvironmentProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureEnvironmentProfile", + "ns2"); + + + + /** + * field for CreateSignatureEnvironmentProfile + */ + + + protected CreateSignatureEnvironmentProfile_type0 localCreateSignatureEnvironmentProfile ; + + + /** + * Auto generated getter method + * @return CreateSignatureEnvironmentProfile_type0 + */ + public CreateSignatureEnvironmentProfile_type0 getCreateSignatureEnvironmentProfile(){ + return localCreateSignatureEnvironmentProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureEnvironmentProfile + */ + public void setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0 param){ + + this.localCreateSignatureEnvironmentProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateSignatureEnvironmentProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureEnvironmentProfile cannot be null!"); + } + localCreateSignatureEnvironmentProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateSignatureEnvironmentProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureEnvironmentProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureEnvironmentProfile object = + new CreateSignatureEnvironmentProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureEnvironmentProfile").equals(reader.getName())){ + + object.setCreateSignatureEnvironmentProfile(CreateSignatureEnvironmentProfile_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class MimeTypeType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "MimeTypeType", + "ns2"); + + + + /** + * field for MimeTypeType + */ + + + protected org.apache.axis2.databinding.types.Token localMimeTypeType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getMimeTypeType(){ + return localMimeTypeType; + } + + + + /** + * Auto generated setter method + * @param param MimeTypeType + */ + public void setMimeTypeType(org.apache.axis2.databinding.types.Token param){ + + this.localMimeTypeType=param; + + + } + + + public java.lang.String toString(){ + + return localMimeTypeType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":MimeTypeType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "MimeTypeType", + xmlWriter); + } + } + + if (localMimeTypeType==null){ + + throw new org.apache.axis2.databinding.ADBException("MimeTypeType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeTypeType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeTypeType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static MimeTypeType fromString(java.lang.String value, + java.lang.String namespaceURI){ + MimeTypeType returnValue = new MimeTypeType(); + + returnValue.setMimeTypeType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + return returnValue; + } + + public static MimeTypeType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return MimeTypeType.Factory.fromString(content,namespaceUri); + } else { + return MimeTypeType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static MimeTypeType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + MimeTypeType object = + new MimeTypeType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"MimeTypeType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setMimeTypeType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CMSDataObjectOptionalMetaType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CMSDataObjectOptionalMetaType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MetaInfo + */ + + + protected MetaInfoType localMetaInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localMetaInfoTracker = false ; + + public boolean isMetaInfoSpecified(){ + return localMetaInfoTracker; + } + + + + /** + * Auto generated getter method + * @return MetaInfoType + */ + public MetaInfoType getMetaInfo(){ + return localMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param MetaInfo + */ + public void setMetaInfo(MetaInfoType param){ + localMetaInfoTracker = param != null; + + this.localMetaInfo=param; + + + } + + + /** + * field for Content + */ + + + protected CMSContentBaseType localContent ; + + + /** + * Auto generated getter method + * @return CMSContentBaseType + */ + public CMSContentBaseType getContent(){ + return localContent; + } + + + + /** + * Auto generated setter method + * @param param Content + */ + public void setContent(CMSContentBaseType param){ + + this.localContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CMSDataObjectOptionalMetaType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CMSDataObjectOptionalMetaType", + xmlWriter); + } + + + } + if (localMetaInfoTracker){ + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + } + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localMetaInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CMSDataObjectOptionalMetaType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CMSDataObjectOptionalMetaType object = + new CMSDataObjectOptionalMetaType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CMSDataObjectOptionalMetaType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CMSDataObjectOptionalMetaType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(CMSContentBaseType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class X509DataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = X509DataType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for X509DataTypeSequence + * This was an Array! + */ + + + protected X509DataTypeSequence[] localX509DataTypeSequence ; + + + /** + * Auto generated getter method + * @return X509DataTypeSequence[] + */ + public X509DataTypeSequence[] getX509DataTypeSequence(){ + return localX509DataTypeSequence; + } + + + + + + + /** + * validate the array for X509DataTypeSequence + */ + protected void validateX509DataTypeSequence(X509DataTypeSequence[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param X509DataTypeSequence + */ + public void setX509DataTypeSequence(X509DataTypeSequence[] param){ + + validateX509DataTypeSequence(param); + + + this.localX509DataTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param X509DataTypeSequence + */ + public void addX509DataTypeSequence(X509DataTypeSequence param){ + if (localX509DataTypeSequence == null){ + localX509DataTypeSequence = new X509DataTypeSequence[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localX509DataTypeSequence); + list.add(param); + this.localX509DataTypeSequence = + (X509DataTypeSequence[])list.toArray( + new X509DataTypeSequence[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":X509DataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "X509DataType", + xmlWriter); + } + + + } + + + if (localX509DataTypeSequence!=null){ + for (int i = 0;i < localX509DataTypeSequence.length;i++){ + if (localX509DataTypeSequence[i] != null){ + localX509DataTypeSequence[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localX509DataTypeSequence!=null) { + for (int i = 0;i < localX509DataTypeSequence.length;i++){ + + if (localX509DataTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "X509DataTypeSequence")); + elementList.add(localX509DataTypeSequence[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("X509DataTypeSequence cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static X509DataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + X509DataType object = + new X509DataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"X509DataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (X509DataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(X509DataTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(X509DataTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setX509DataTypeSequence((X509DataTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + X509DataTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureProperties + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureProperties", + "ns1"); + + + + /** + * field for SignatureProperties + */ + + + protected SignaturePropertiesType localSignatureProperties ; + + + /** + * Auto generated getter method + * @return SignaturePropertiesType + */ + public SignaturePropertiesType getSignatureProperties(){ + return localSignatureProperties; + } + + + + /** + * Auto generated setter method + * @param param SignatureProperties + */ + public void setSignatureProperties(SignaturePropertiesType param){ + + this.localSignatureProperties=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureProperties==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureProperties cannot be null!"); + } + localSignatureProperties.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureProperties.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureProperties parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureProperties object = + new SignatureProperties(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperties").equals(reader.getName())){ + + object.setSignatureProperties(SignaturePropertiesType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyName + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "KeyName", + "ns1"); + + + + /** + * field for KeyName + */ + + + protected java.lang.String localKeyName ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getKeyName(){ + return localKeyName; + } + + + + /** + * Auto generated setter method + * @param param KeyName + */ + public void setKeyName(java.lang.String param){ + + this.localKeyName=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = "http://www.w3.org/2000/09/xmldsig#"; + java.lang.String _localName = "KeyName"; + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyName", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyName", + xmlWriter); + } + } + + if (localKeyName==null){ + + throw new org.apache.axis2.databinding.ADBException("KeyName cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localKeyName); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localKeyName) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyName parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyName object = + new KeyName(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyName").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"KeyName" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setKeyName( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateCMSSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for KeyIdentifier + */ + + + protected KeyIdentifierType localKeyIdentifier ; + + + /** + * Auto generated getter method + * @return KeyIdentifierType + */ + public KeyIdentifierType getKeyIdentifier(){ + return localKeyIdentifier; + } + + + + /** + * Auto generated setter method + * @param param KeyIdentifier + */ + public void setKeyIdentifier(KeyIdentifierType param){ + + this.localKeyIdentifier=param; + + + } + + + /** + * field for SingleSignatureInfo + * This was an Array! + */ + + + protected SingleSignatureInfo_type1[] localSingleSignatureInfo ; + + + /** + * Auto generated getter method + * @return SingleSignatureInfo_type1[] + */ + public SingleSignatureInfo_type1[] getSingleSignatureInfo(){ + return localSingleSignatureInfo; + } + + + + + + + /** + * validate the array for SingleSignatureInfo + */ + protected void validateSingleSignatureInfo(SingleSignatureInfo_type1[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SingleSignatureInfo + */ + public void setSingleSignatureInfo(SingleSignatureInfo_type1[] param){ + + validateSingleSignatureInfo(param); + + + this.localSingleSignatureInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SingleSignatureInfo_type1 + */ + public void addSingleSignatureInfo(SingleSignatureInfo_type1 param){ + if (localSingleSignatureInfo == null){ + localSingleSignatureInfo = new SingleSignatureInfo_type1[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSingleSignatureInfo); + list.add(param); + this.localSingleSignatureInfo = + (SingleSignatureInfo_type1[])list.toArray( + new SingleSignatureInfo_type1[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureRequestType", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureRequestType object = + new CreateCMSSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateCMSSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateCMSSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type1[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type1.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateXMLSignatureResponse", + "ns2"); + + + + /** + * field for CreateXMLSignatureResponse + */ + + + protected CreateXMLSignatureResponseType localCreateXMLSignatureResponse ; + + + /** + * Auto generated getter method + * @return CreateXMLSignatureResponseType + */ + public CreateXMLSignatureResponseType getCreateXMLSignatureResponse(){ + return localCreateXMLSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param CreateXMLSignatureResponse + */ + public void setCreateXMLSignatureResponse(CreateXMLSignatureResponseType param){ + + this.localCreateXMLSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateXMLSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponse cannot be null!"); + } + localCreateXMLSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateXMLSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureResponse object = + new CreateXMLSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateXMLSignatureResponse").equals(reader.getName())){ + + object.setCreateXMLSignatureResponse(CreateXMLSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class IssuingCountry + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "IssuingCountry", + "ns2"); + + + + /** + * field for IssuingCountry + */ + + + protected org.apache.axis2.databinding.types.Token localIssuingCountry ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getIssuingCountry(){ + return localIssuingCountry; + } + + + + /** + * Auto generated setter method + * @param param IssuingCountry + */ + public void setIssuingCountry(org.apache.axis2.databinding.types.Token param){ + + this.localIssuingCountry=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + java.lang.String _localName = "IssuingCountry"; + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":IssuingCountry", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "IssuingCountry", + xmlWriter); + } + } + + if (localIssuingCountry==null){ + + throw new org.apache.axis2.databinding.ADBException("IssuingCountry cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIssuingCountry)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIssuingCountry) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static IssuingCountry parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + IssuingCountry object = + new IssuingCountry(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","IssuingCountry").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"IssuingCountry" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setIssuingCountry( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Hash_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = Hash_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DigestMethod + */ + + + protected DigestMethodType localDigestMethod ; + + + /** + * Auto generated getter method + * @return DigestMethodType + */ + public DigestMethodType getDigestMethod(){ + return localDigestMethod; + } + + + + /** + * Auto generated setter method + * @param param DigestMethod + */ + public void setDigestMethod(DigestMethodType param){ + + this.localDigestMethod=param; + + + } + + + /** + * field for DigestValue + */ + + + protected DigestValueType localDigestValue ; + + + /** + * Auto generated getter method + * @return DigestValueType + */ + public DigestValueType getDigestValue(){ + return localDigestValue; + } + + + + /** + * Auto generated setter method + * @param param DigestValue + */ + public void setDigestValue(DigestValueType param){ + + this.localDigestValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":Hash_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "Hash_type0", + xmlWriter); + } + + + } + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + localDigestMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod"), + xmlWriter); + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + localDigestValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestMethod")); + + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + elementList.add(localDigestMethod); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestValue")); + + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + elementList.add(localDigestValue); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Hash_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Hash_type0 object = + new Hash_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"Hash_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (Hash_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod").equals(reader.getName())){ + + object.setDigestMethod(DigestMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue").equals(reader.getName())){ + + object.setDigestValue(DigestValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class PublicAuthorityType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = PublicAuthorityType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected java.lang.String localCode ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCodeTracker = false ; + + public boolean isCodeSpecified(){ + return localCodeTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(java.lang.String param){ + localCodeTracker = param != null; + + this.localCode=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":PublicAuthorityType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "PublicAuthorityType", + xmlWriter); + } + + + } + if (localCodeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localCode); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localCodeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static PublicAuthorityType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + PublicAuthorityType object = + new PublicAuthorityType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"PublicAuthorityType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (PublicAuthorityType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateTransformsInfoProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfoProfile", + "ns2"); + + + + /** + * field for CreateTransformsInfoProfile + */ + + + protected CreateTransformsInfoProfile_type0 localCreateTransformsInfoProfile ; + + + /** + * Auto generated getter method + * @return CreateTransformsInfoProfile_type0 + */ + public CreateTransformsInfoProfile_type0 getCreateTransformsInfoProfile(){ + return localCreateTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfoProfile + */ + public void setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0 param){ + + this.localCreateTransformsInfoProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfoProfile cannot be null!"); + } + localCreateTransformsInfoProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateTransformsInfoProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateTransformsInfoProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateTransformsInfoProfile object = + new CreateTransformsInfoProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfoProfile").equals(reader.getName())){ + + object.setCreateTransformsInfoProfile(CreateTransformsInfoProfile_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyCMSSignatureResponse", + "ns2"); + + + + /** + * field for VerifyCMSSignatureResponse + */ + + + protected VerifyCMSSignatureResponseType localVerifyCMSSignatureResponse ; + + + /** + * Auto generated getter method + * @return VerifyCMSSignatureResponseType + */ + public VerifyCMSSignatureResponseType getVerifyCMSSignatureResponse(){ + return localVerifyCMSSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param VerifyCMSSignatureResponse + */ + public void setVerifyCMSSignatureResponse(VerifyCMSSignatureResponseType param){ + + this.localVerifyCMSSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyCMSSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponse cannot be null!"); + } + localVerifyCMSSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyCMSSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureResponse object = + new VerifyCMSSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyCMSSignatureResponse").equals(reader.getName())){ + + object.setVerifyCMSSignatureResponse(VerifyCMSSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateCMSSignatureResponse", + "ns2"); + + + + /** + * field for CreateCMSSignatureResponse + */ + + + protected CreateCMSSignatureResponseType localCreateCMSSignatureResponse ; + + + /** + * Auto generated getter method + * @return CreateCMSSignatureResponseType + */ + public CreateCMSSignatureResponseType getCreateCMSSignatureResponse(){ + return localCreateCMSSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param CreateCMSSignatureResponse + */ + public void setCreateCMSSignatureResponse(CreateCMSSignatureResponseType param){ + + this.localCreateCMSSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localCreateCMSSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("CreateCMSSignatureResponse cannot be null!"); + } + localCreateCMSSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localCreateCMSSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureResponse object = + new CreateCMSSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateCMSSignatureResponse").equals(reader.getName())){ + + object.setCreateCMSSignatureResponse(CreateCMSSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SupplementProfile + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "SupplementProfile", + "ns2"); + + + + /** + * field for SupplementProfile + */ + + + protected XMLDataObjectAssociationType localSupplementProfile ; + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType + */ + public XMLDataObjectAssociationType getSupplementProfile(){ + return localSupplementProfile; + } + + + + /** + * Auto generated setter method + * @param param SupplementProfile + */ + public void setSupplementProfile(XMLDataObjectAssociationType param){ + + this.localSupplementProfile=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSupplementProfile==null){ + throw new org.apache.axis2.databinding.ADBException("SupplementProfile cannot be null!"); + } + localSupplementProfile.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSupplementProfile.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SupplementProfile parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SupplementProfile object = + new SupplementProfile(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SupplementProfile").equals(reader.getName())){ + + object.setSupplementProfile(XMLDataObjectAssociationType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureResponseTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyCMSSignatureResponseTypeSequence + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for SignerInfo + */ + + + protected KeyInfoType localSignerInfo ; + + + /** + * Auto generated getter method + * @return KeyInfoType + */ + public KeyInfoType getSignerInfo(){ + return localSignerInfo; + } + + + + /** + * Auto generated setter method + * @param param SignerInfo + */ + public void setSignerInfo(KeyInfoType param){ + + this.localSignerInfo=param; + + + } + + + /** + * field for SignatureCheck + */ + + + protected CheckResultType localSignatureCheck ; + + + /** + * Auto generated getter method + * @return CheckResultType + */ + public CheckResultType getSignatureCheck(){ + return localSignatureCheck; + } + + + + /** + * Auto generated setter method + * @param param SignatureCheck + */ + public void setSignatureCheck(CheckResultType param){ + + this.localSignatureCheck=param; + + + } + + + /** + * field for CertificateCheck + */ + + + protected CheckResultType localCertificateCheck ; + + + /** + * Auto generated getter method + * @return CheckResultType + */ + public CheckResultType getCertificateCheck(){ + return localCertificateCheck; + } + + + + /** + * Auto generated setter method + * @param param CertificateCheck + */ + public void setCertificateCheck(CheckResultType param){ + + this.localCertificateCheck=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureResponseTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureResponseTypeSequence", + xmlWriter); + } + + + } + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + localSignerInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo"), + xmlWriter); + + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + localSignatureCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck"), + xmlWriter); + + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + localCertificateCheck.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck"), + xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignerInfo")); + + + if (localSignerInfo==null){ + throw new org.apache.axis2.databinding.ADBException("SignerInfo cannot be null!!"); + } + elementList.add(localSignerInfo); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureCheck")); + + + if (localSignatureCheck==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureCheck cannot be null!!"); + } + elementList.add(localSignatureCheck); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CertificateCheck")); + + + if (localCertificateCheck==null){ + throw new org.apache.axis2.databinding.ADBException("CertificateCheck cannot be null!!"); + } + elementList.add(localCertificateCheck); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureResponseTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureResponseTypeSequence object = + new VerifyCMSSignatureResponseTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignerInfo").equals(reader.getName())){ + + object.setSignerInfo(KeyInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureCheck").equals(reader.getName())){ + + object.setSignatureCheck(CheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CertificateCheck").equals(reader.getName())){ + + object.setCertificateCheck(CheckResultType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RetrievalMethod + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "RetrievalMethod", + "ns1"); + + + + /** + * field for RetrievalMethod + */ + + + protected RetrievalMethodType localRetrievalMethod ; + + + /** + * Auto generated getter method + * @return RetrievalMethodType + */ + public RetrievalMethodType getRetrievalMethod(){ + return localRetrievalMethod; + } + + + + /** + * Auto generated setter method + * @param param RetrievalMethod + */ + public void setRetrievalMethod(RetrievalMethodType param){ + + this.localRetrievalMethod=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localRetrievalMethod==null){ + throw new org.apache.axis2.databinding.ADBException("RetrievalMethod cannot be null!"); + } + localRetrievalMethod.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localRetrievalMethod.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RetrievalMethod parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RetrievalMethod object = + new RetrievalMethod(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RetrievalMethod").equals(reader.getName())){ + + object.setRetrievalMethod(RetrievalMethodType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateCMSSignatureRequest extends CreateCMSSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateCMSSignatureRequest", + "ns2"); + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateCMSSignatureRequest", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateCMSSignatureRequest", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateCMSSignatureRequest")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateCMSSignatureRequest parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateCMSSignatureRequest object = + new CreateCMSSignatureRequest(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateCMSSignatureRequest".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateCMSSignatureRequest)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type1.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type1[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type1.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyCMSSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyCMSSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for VerifyCMSSignatureResponseTypeSequence + * This was an Array! + */ + + + protected VerifyCMSSignatureResponseTypeSequence[] localVerifyCMSSignatureResponseTypeSequence ; + + + /** + * Auto generated getter method + * @return VerifyCMSSignatureResponseTypeSequence[] + */ + public VerifyCMSSignatureResponseTypeSequence[] getVerifyCMSSignatureResponseTypeSequence(){ + return localVerifyCMSSignatureResponseTypeSequence; + } + + + + + + + /** + * validate the array for VerifyCMSSignatureResponseTypeSequence + */ + protected void validateVerifyCMSSignatureResponseTypeSequence(VerifyCMSSignatureResponseTypeSequence[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param VerifyCMSSignatureResponseTypeSequence + */ + public void setVerifyCMSSignatureResponseTypeSequence(VerifyCMSSignatureResponseTypeSequence[] param){ + + validateVerifyCMSSignatureResponseTypeSequence(param); + + + this.localVerifyCMSSignatureResponseTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyCMSSignatureResponseTypeSequence + */ + public void addVerifyCMSSignatureResponseTypeSequence(VerifyCMSSignatureResponseTypeSequence param){ + if (localVerifyCMSSignatureResponseTypeSequence == null){ + localVerifyCMSSignatureResponseTypeSequence = new VerifyCMSSignatureResponseTypeSequence[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localVerifyCMSSignatureResponseTypeSequence); + list.add(param); + this.localVerifyCMSSignatureResponseTypeSequence = + (VerifyCMSSignatureResponseTypeSequence[])list.toArray( + new VerifyCMSSignatureResponseTypeSequence[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyCMSSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyCMSSignatureResponseType", + xmlWriter); + } + + + } + + + if (localVerifyCMSSignatureResponseTypeSequence!=null){ + for (int i = 0;i < localVerifyCMSSignatureResponseTypeSequence.length;i++){ + if (localVerifyCMSSignatureResponseTypeSequence[i] != null){ + localVerifyCMSSignatureResponseTypeSequence[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localVerifyCMSSignatureResponseTypeSequence!=null) { + for (int i = 0;i < localVerifyCMSSignatureResponseTypeSequence.length;i++){ + + if (localVerifyCMSSignatureResponseTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyCMSSignatureResponseTypeSequence")); + elementList.add(localVerifyCMSSignatureResponseTypeSequence[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyCMSSignatureResponseTypeSequence cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyCMSSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyCMSSignatureResponseType object = + new VerifyCMSSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyCMSSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyCMSSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(VerifyCMSSignatureResponseTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(VerifyCMSSignatureResponseTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setVerifyCMSSignatureResponseTypeSequence((VerifyCMSSignatureResponseTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyCMSSignatureResponseTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ReferencesCheckResultType extends CheckResultType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ReferencesCheckResultType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localCode ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localCode=param; + + + } + + + /** + * field for Info0 + * Type of this field is a subtype of its original. + */ + + + protected ReferencesCheckResultInfoType localInfo0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localInfo0Tracker = false ; + + public boolean isInfo0Specified(){ + return localInfo0Tracker; + } + + + + /** + * Auto generated getter method + * @return ReferencesCheckResultInfoType + */ + public ReferencesCheckResultInfoType getInfo0(){ + return localInfo0; + } + + + + /** + * Auto generated setter method + * @param param Info0 + */ + public void setInfo0(ReferencesCheckResultInfoType param){ + localInfo0Tracker = param != null; + + this.localInfo0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ReferencesCheckResultType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ReferencesCheckResultType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + + } + + xmlWriter.writeEndElement(); + if (localInfo0Tracker){ + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + localInfo0.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + if (localInfo0Tracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info0")); + + + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + elementList.add(localInfo0); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ReferencesCheckResultType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ReferencesCheckResultType object = + new ReferencesCheckResultType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ReferencesCheckResultType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ReferencesCheckResultType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0").equals(reader.getName())){ + + object.setInfo0(ReferencesCheckResultInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ExtensionMapper{ + + public static java.lang.Object getTypeObject(java.lang.String namespaceURI, + java.lang.String typeName, + javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentOptionalRefType".equals(typeName)){ + + return ContentOptionalRefType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyXMLSignatureResponseType".equals(typeName)){ + + return VerifyXMLSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyTransformsInfoProfile_type0".equals(typeName)){ + + return VerifyTransformsInfoProfile_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSDataObjectInfoType".equals(typeName)){ + + return CMSDataObjectInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "PartOf_type0".equals(typeName)){ + + return PartOf_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ManifestRefsCheckResultInfoType".equals(typeName)){ + + return ManifestRefsCheckResultInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "AnyChildrenType".equals(typeName)){ + + return AnyChildrenType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "XMLContentType".equals(typeName)){ + + return XMLContentType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObjectInfoType".equals(typeName)){ + + return DataObjectInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateCMSSignatureResponseType".equals(typeName)){ + + return CreateCMSSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "PGPDataType".equals(typeName)){ + + return PGPDataType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignatureType".equals(typeName)){ + + return SignatureType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "FinalDataMetaInfoType".equals(typeName)){ + + return FinalDataMetaInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentBaseType".equals(typeName)){ + + return ContentBaseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSDataObjectRequiredMetaType".equals(typeName)){ + + return CMSDataObjectRequiredMetaType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ReferencesCheckResultInfoType".equals(typeName)){ + + return ReferencesCheckResultInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObject_type1".equals(typeName)){ + + return DataObject_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObject_type0".equals(typeName)){ + + return DataObject_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "source_type1".equals(typeName)){ + + return Source_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSContentBaseType".equals(typeName)){ + + return CMSContentBaseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "source_type0".equals(typeName)){ + + return Source_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignaturePropertiesType".equals(typeName)){ + + return SignaturePropertiesType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SignatoriesType".equals(typeName)){ + + return SignatoriesType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "X509IssuerSerialType".equals(typeName)){ + + return X509IssuerSerialType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "DSAKeyValueType".equals(typeName)){ + + return DSAKeyValueType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "KeyValueType".equals(typeName)){ + + return KeyValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyCMSSignatureRequestType".equals(typeName)){ + + return VerifyCMSSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentRequiredRefType".equals(typeName)){ + + return ContentRequiredRefType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateSignatureInfo_type0".equals(typeName)){ + + return CreateSignatureInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "CryptoBinary".equals(typeName)){ + + return CryptoBinary.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SPKIDataType".equals(typeName)){ + + return SPKIDataType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifySignatureInfo_type0".equals(typeName)){ + + return VerifySignatureInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "CanonicalizationMethodType".equals(typeName)){ + + return CanonicalizationMethodType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "MimeTypeType".equals(typeName)){ + + return MimeTypeType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CMSDataObjectOptionalMetaType".equals(typeName)){ + + return CMSDataObjectOptionalMetaType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "X509DataType".equals(typeName)){ + + return X509DataType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateCMSSignatureRequestType".equals(typeName)){ + + return CreateCMSSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "Hash_type0".equals(typeName)){ + + return Hash_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "PublicAuthorityType".equals(typeName)){ + + return PublicAuthorityType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyCMSSignatureResponseType".equals(typeName)){ + + return VerifyCMSSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ReferencesCheckResultType".equals(typeName)){ + + return ReferencesCheckResultType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SignatureManifestCheckParams_type0".equals(typeName)){ + + return SignatureManifestCheckParams_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "MetaInfoType".equals(typeName)){ + + return MetaInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SingleSignatureInfo_type0".equals(typeName)){ + + return SingleSignatureInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "RSAKeyValueType".equals(typeName)){ + + return RSAKeyValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SingleSignatureInfo_type1".equals(typeName)){ + + return SingleSignatureInfo_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "XMLDataObjectAssociationType".equals(typeName)){ + + return XMLDataObjectAssociationType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "KeyIdentifierType".equals(typeName)){ + + return KeyIdentifierType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignedInfoType".equals(typeName)){ + + return SignedInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ErrorResponseType".equals(typeName)){ + + return ErrorResponseType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignatureMethodType".equals(typeName)){ + + return SignatureMethodType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignaturePropertyType".equals(typeName)){ + + return SignaturePropertyType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "RetrievalMethodType".equals(typeName)){ + + return RetrievalMethodType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "TransformType".equals(typeName)){ + + return TransformType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateSignatureEnvironmentProfile_type0".equals(typeName)){ + + return CreateSignatureEnvironmentProfile_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "Structure_type1".equals(typeName)){ + + return Structure_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "InputDataType".equals(typeName)){ + + return InputDataType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "Structure_type0".equals(typeName)){ + + return Structure_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "SignatureEnvironment_type0".equals(typeName)){ + + return SignatureEnvironment_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "DigestValueType".equals(typeName)){ + + return DigestValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObjectInfo_type1".equals(typeName)){ + + return DataObjectInfo_type1.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "DataObjectInfo_type0".equals(typeName)){ + + return DataObjectInfo_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/XML/1998/namespace".equals(namespaceURI) && + "space_type0".equals(typeName)){ + + return Space_type0.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "ReferenceType".equals(typeName)){ + + return ReferenceType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "KeyInfoType".equals(typeName)){ + + return KeyInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyTransformsDataType".equals(typeName)){ + + return VerifyTransformsDataType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "DigestMethodType".equals(typeName)){ + + return DigestMethodType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "AllSignatoriesType".equals(typeName)){ + + return AllSignatoriesType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "TransformsInfoType".equals(typeName)){ + + return TransformsInfoType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ContentExLocRefBaseType".equals(typeName)){ + + return ContentExLocRefBaseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateXMLSignatureRequestType".equals(typeName)){ + + return CreateXMLSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "SignatureValueType".equals(typeName)){ + + return SignatureValueType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "TransformParameterType".equals(typeName)){ + + return TransformParameterType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "ManifestType".equals(typeName)){ + + return ManifestType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "HMACOutputLengthType".equals(typeName)){ + + return HMACOutputLengthType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateSignatureLocationType".equals(typeName)){ + + return CreateSignatureLocationType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "TransformsType".equals(typeName)){ + + return TransformsType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateXMLSignatureResponseType".equals(typeName)){ + + return CreateXMLSignatureResponseType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CreateTransformsInfoProfile_type0".equals(typeName)){ + + return CreateTransformsInfoProfile_type0.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "VerifyXMLSignatureRequestType".equals(typeName)){ + + return VerifyXMLSignatureRequestType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ProfileIdentifierType".equals(typeName)){ + + return ProfileIdentifierType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "ManifestRefsCheckResultType".equals(typeName)){ + + return ManifestRefsCheckResultType.Factory.parse(reader); + + + } + + + if ( + "http://reference.e-government.gv.at/namespace/moa/20020822#".equals(namespaceURI) && + "CheckResultType".equals(typeName)){ + + return CheckResultType.Factory.parse(reader); + + + } + + + if ( + "http://www.w3.org/2000/09/xmldsig#".equals(namespaceURI) && + "ObjectType".equals(typeName)){ + + return ObjectType.Factory.parse(reader); + + + } + + + throw new org.apache.axis2.databinding.ADBException("Unsupported type " + namespaceURI + " " + typeName); + } + + } + + public static class SignatureManifestCheckParams_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureManifestCheckParams_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ReferenceInfo + * This was an Array! + */ + + + protected VerifyTransformsDataType[] localReferenceInfo ; + + + /** + * Auto generated getter method + * @return VerifyTransformsDataType[] + */ + public VerifyTransformsDataType[] getReferenceInfo(){ + return localReferenceInfo; + } + + + + + + + /** + * validate the array for ReferenceInfo + */ + protected void validateReferenceInfo(VerifyTransformsDataType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param ReferenceInfo + */ + public void setReferenceInfo(VerifyTransformsDataType[] param){ + + validateReferenceInfo(param); + + + this.localReferenceInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyTransformsDataType + */ + public void addReferenceInfo(VerifyTransformsDataType param){ + if (localReferenceInfo == null){ + localReferenceInfo = new VerifyTransformsDataType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReferenceInfo); + list.add(param); + this.localReferenceInfo = + (VerifyTransformsDataType[])list.toArray( + new VerifyTransformsDataType[list.size()]); + + } + + + /** + * field for ReturnReferenceInputData + * This was an Attribute! + */ + + + protected boolean localReturnReferenceInputData = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("true"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getReturnReferenceInputData(){ + return localReturnReferenceInputData; + } + + + + /** + * Auto generated setter method + * @param param ReturnReferenceInputData + */ + public void setReturnReferenceInputData(boolean param){ + + this.localReturnReferenceInputData=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureManifestCheckParams_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureManifestCheckParams_type0", + xmlWriter); + } + + + } + + if (true) { + + writeAttribute("", + "ReturnReferenceInputData", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReturnReferenceInputData), xmlWriter); + + + } + + if (localReferenceInfo!=null){ + for (int i = 0;i < localReferenceInfo.length;i++){ + if (localReferenceInfo[i] != null){ + localReferenceInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localReferenceInfo!=null) { + for (int i = 0;i < localReferenceInfo.length;i++){ + + if (localReferenceInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReferenceInfo")); + elementList.add(localReferenceInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ReferenceInfo cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","ReturnReferenceInputData")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReturnReferenceInputData)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureManifestCheckParams_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureManifestCheckParams_type0 object = + new SignatureManifestCheckParams_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureManifestCheckParams_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureManifestCheckParams_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "ReturnReferenceInputData" + java.lang.String tempAttribReturnReferenceInputData = + + reader.getAttributeValue(null,"ReturnReferenceInputData"); + + if (tempAttribReturnReferenceInputData!=null){ + java.lang.String content = tempAttribReturnReferenceInputData; + + object.setReturnReferenceInputData( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribReturnReferenceInputData)); + + } else { + + } + handledAttributes.add("ReturnReferenceInputData"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(VerifyTransformsDataType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ReferenceInfo").equals(reader.getName())){ + list1.add(VerifyTransformsDataType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReferenceInfo((VerifyTransformsDataType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyTransformsDataType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class MetaInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = MetaInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MimeType + */ + + + protected MimeTypeType localMimeType ; + + + /** + * Auto generated getter method + * @return MimeTypeType + */ + public MimeTypeType getMimeType(){ + return localMimeType; + } + + + + /** + * Auto generated setter method + * @param param MimeType + */ + public void setMimeType(MimeTypeType param){ + + this.localMimeType=param; + + + } + + + /** + * field for Description + */ + + + protected org.apache.axis2.databinding.types.URI localDescription ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDescriptionTracker = false ; + + public boolean isDescriptionSpecified(){ + return localDescriptionTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getDescription(){ + return localDescription; + } + + + + /** + * Auto generated setter method + * @param param Description + */ + public void setDescription(org.apache.axis2.databinding.types.URI param){ + localDescriptionTracker = param != null; + + this.localDescription=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":MetaInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "MetaInfoType", + xmlWriter); + } + + + } + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + localMimeType.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType"), + xmlWriter); + if (localDescriptionTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Description", xmlWriter); + + + if (localDescription==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + + } + + xmlWriter.writeEndElement(); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MimeType")); + + + if (localMimeType==null){ + throw new org.apache.axis2.databinding.ADBException("MimeType cannot be null!!"); + } + elementList.add(localMimeType); + if (localDescriptionTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Description")); + + if (localDescription != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDescription)); + } else { + throw new org.apache.axis2.databinding.ADBException("Description cannot be null!!"); + } + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static MetaInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + MetaInfoType object = + new MetaInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"MetaInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (MetaInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MimeType").equals(reader.getName())){ + + object.setMimeType(MimeTypeType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Description").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Description" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDescription( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone3=false; + + while (!loopDone3){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder3 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list3.add(builder3.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone3 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone3 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list3)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureProperty + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureProperty", + "ns1"); + + + + /** + * field for SignatureProperty + */ + + + protected SignaturePropertyType localSignatureProperty ; + + + /** + * Auto generated getter method + * @return SignaturePropertyType + */ + public SignaturePropertyType getSignatureProperty(){ + return localSignatureProperty; + } + + + + /** + * Auto generated setter method + * @param param SignatureProperty + */ + public void setSignatureProperty(SignaturePropertyType param){ + + this.localSignatureProperty=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureProperty==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureProperty cannot be null!"); + } + localSignatureProperty.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureProperty.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureProperty parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureProperty object = + new SignatureProperty(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureProperty").equals(reader.getName())){ + + object.setSignatureProperty(SignaturePropertyType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SingleSignatureInfo_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SingleSignatureInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObjectInfo + * This was an Array! + */ + + + protected DataObjectInfo_type0[] localDataObjectInfo ; + + + /** + * Auto generated getter method + * @return DataObjectInfo_type0[] + */ + public DataObjectInfo_type0[] getDataObjectInfo(){ + return localDataObjectInfo; + } + + + + + + + /** + * validate the array for DataObjectInfo + */ + protected void validateDataObjectInfo(DataObjectInfo_type0[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param DataObjectInfo + */ + public void setDataObjectInfo(DataObjectInfo_type0[] param){ + + validateDataObjectInfo(param); + + + this.localDataObjectInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param DataObjectInfo_type0 + */ + public void addDataObjectInfo(DataObjectInfo_type0 param){ + if (localDataObjectInfo == null){ + localDataObjectInfo = new DataObjectInfo_type0[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localDataObjectInfo); + list.add(param); + this.localDataObjectInfo = + (DataObjectInfo_type0[])list.toArray( + new DataObjectInfo_type0[list.size()]); + + } + + + /** + * field for CreateSignatureInfo + */ + + + protected CreateSignatureInfo_type0 localCreateSignatureInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localCreateSignatureInfoTracker = false ; + + public boolean isCreateSignatureInfoSpecified(){ + return localCreateSignatureInfoTracker; + } + + + + /** + * Auto generated getter method + * @return CreateSignatureInfo_type0 + */ + public CreateSignatureInfo_type0 getCreateSignatureInfo(){ + return localCreateSignatureInfo; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureInfo + */ + public void setCreateSignatureInfo(CreateSignatureInfo_type0 param){ + localCreateSignatureInfoTracker = param != null; + + this.localCreateSignatureInfo=param; + + + } + + + /** + * field for SecurityLayerConformity + * This was an Attribute! + */ + + + protected boolean localSecurityLayerConformity = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("true"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getSecurityLayerConformity(){ + return localSecurityLayerConformity; + } + + + + /** + * Auto generated setter method + * @param param SecurityLayerConformity + */ + public void setSecurityLayerConformity(boolean param){ + + this.localSecurityLayerConformity=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SingleSignatureInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SingleSignatureInfo_type0", + xmlWriter); + } + + + } + + if (true) { + + writeAttribute("", + "SecurityLayerConformity", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity), xmlWriter); + + + } + + if (localDataObjectInfo!=null){ + for (int i = 0;i < localDataObjectInfo.length;i++){ + if (localDataObjectInfo[i] != null){ + localDataObjectInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + + } + if (localCreateSignatureInfoTracker){ + if (localCreateSignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfo cannot be null!!"); + } + localCreateSignatureInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureInfo"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localDataObjectInfo!=null) { + for (int i = 0;i < localDataObjectInfo.length;i++){ + + if (localDataObjectInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfo")); + elementList.add(localDataObjectInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + + } + + if (localCreateSignatureInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureInfo")); + + + if (localCreateSignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureInfo cannot be null!!"); + } + elementList.add(localCreateSignatureInfo); + } + attribList.add( + new javax.xml.namespace.QName("","SecurityLayerConformity")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SingleSignatureInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SingleSignatureInfo_type0 object = + new SingleSignatureInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SingleSignatureInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SingleSignatureInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "SecurityLayerConformity" + java.lang.String tempAttribSecurityLayerConformity = + + reader.getAttributeValue(null,"SecurityLayerConformity"); + + if (tempAttribSecurityLayerConformity!=null){ + java.lang.String content = tempAttribSecurityLayerConformity; + + object.setSecurityLayerConformity( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribSecurityLayerConformity)); + + } else { + + } + handledAttributes.add("SecurityLayerConformity"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(DataObjectInfo_type0.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo").equals(reader.getName())){ + list1.add(DataObjectInfo_type0.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setDataObjectInfo((DataObjectInfo_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + DataObjectInfo_type0.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureInfo").equals(reader.getName())){ + + object.setCreateSignatureInfo(CreateSignatureInfo_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RSAKeyValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = RSAKeyValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Modulus + */ + + + protected CryptoBinary localModulus ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getModulus(){ + return localModulus; + } + + + + /** + * Auto generated setter method + * @param param Modulus + */ + public void setModulus(CryptoBinary param){ + + this.localModulus=param; + + + } + + + /** + * field for Exponent + */ + + + protected CryptoBinary localExponent ; + + + /** + * Auto generated getter method + * @return CryptoBinary + */ + public CryptoBinary getExponent(){ + return localExponent; + } + + + + /** + * Auto generated setter method + * @param param Exponent + */ + public void setExponent(CryptoBinary param){ + + this.localExponent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":RSAKeyValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "RSAKeyValueType", + xmlWriter); + } + + + } + + if (localModulus==null){ + throw new org.apache.axis2.databinding.ADBException("Modulus cannot be null!!"); + } + localModulus.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Modulus"), + xmlWriter); + + if (localExponent==null){ + throw new org.apache.axis2.databinding.ADBException("Exponent cannot be null!!"); + } + localExponent.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Exponent"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Modulus")); + + + if (localModulus==null){ + throw new org.apache.axis2.databinding.ADBException("Modulus cannot be null!!"); + } + elementList.add(localModulus); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Exponent")); + + + if (localExponent==null){ + throw new org.apache.axis2.databinding.ADBException("Exponent cannot be null!!"); + } + elementList.add(localExponent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RSAKeyValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RSAKeyValueType object = + new RSAKeyValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"RSAKeyValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (RSAKeyValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Modulus").equals(reader.getName())){ + + object.setModulus(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Exponent").equals(reader.getName())){ + + object.setExponent(CryptoBinary.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SingleSignatureInfo_type1 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SingleSignatureInfo_type1 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DataObjectInfo + */ + + + protected DataObjectInfo_type1 localDataObjectInfo ; + + + /** + * Auto generated getter method + * @return DataObjectInfo_type1 + */ + public DataObjectInfo_type1 getDataObjectInfo(){ + return localDataObjectInfo; + } + + + + /** + * Auto generated setter method + * @param param DataObjectInfo + */ + public void setDataObjectInfo(DataObjectInfo_type1 param){ + + this.localDataObjectInfo=param; + + + } + + + /** + * field for SecurityLayerConformity + * This was an Attribute! + */ + + + protected boolean localSecurityLayerConformity = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("true"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getSecurityLayerConformity(){ + return localSecurityLayerConformity; + } + + + + /** + * Auto generated setter method + * @param param SecurityLayerConformity + */ + public void setSecurityLayerConformity(boolean param){ + + this.localSecurityLayerConformity=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SingleSignatureInfo_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SingleSignatureInfo_type1", + xmlWriter); + } + + + } + + if (true) { + + writeAttribute("", + "SecurityLayerConformity", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity), xmlWriter); + + + } + + if (localDataObjectInfo==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + } + localDataObjectInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfo")); + + + if (localDataObjectInfo==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfo cannot be null!!"); + } + elementList.add(localDataObjectInfo); + + attribList.add( + new javax.xml.namespace.QName("","SecurityLayerConformity")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSecurityLayerConformity)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SingleSignatureInfo_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SingleSignatureInfo_type1 object = + new SingleSignatureInfo_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SingleSignatureInfo_type1".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SingleSignatureInfo_type1)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "SecurityLayerConformity" + java.lang.String tempAttribSecurityLayerConformity = + + reader.getAttributeValue(null,"SecurityLayerConformity"); + + if (tempAttribSecurityLayerConformity!=null){ + java.lang.String content = tempAttribSecurityLayerConformity; + + object.setSecurityLayerConformity( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribSecurityLayerConformity)); + + } else { + + } + handledAttributes.add("SecurityLayerConformity"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo").equals(reader.getName())){ + + object.setDataObjectInfo(DataObjectInfo_type1.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class XMLDataObjectAssociationType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = XMLDataObjectAssociationType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for MetaInfo + */ + + + protected MetaInfoType localMetaInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localMetaInfoTracker = false ; + + public boolean isMetaInfoSpecified(){ + return localMetaInfoTracker; + } + + + + /** + * Auto generated getter method + * @return MetaInfoType + */ + public MetaInfoType getMetaInfo(){ + return localMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param MetaInfo + */ + public void setMetaInfo(MetaInfoType param){ + localMetaInfoTracker = param != null; + + this.localMetaInfo=param; + + + } + + + /** + * field for Content + */ + + + protected ContentRequiredRefType localContent ; + + + /** + * Auto generated getter method + * @return ContentRequiredRefType + */ + public ContentRequiredRefType getContent(){ + return localContent; + } + + + + /** + * Auto generated setter method + * @param param Content + */ + public void setContent(ContentRequiredRefType param){ + + this.localContent=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":XMLDataObjectAssociationType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "XMLDataObjectAssociationType", + xmlWriter); + } + + + } + if (localMetaInfoTracker){ + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + localMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo"), + xmlWriter); + } + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + localContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localMetaInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "MetaInfo")); + + + if (localMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("MetaInfo cannot be null!!"); + } + elementList.add(localMetaInfo); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Content")); + + + if (localContent==null){ + throw new org.apache.axis2.databinding.ADBException("Content cannot be null!!"); + } + elementList.add(localContent); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static XMLDataObjectAssociationType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + XMLDataObjectAssociationType object = + new XMLDataObjectAssociationType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"XMLDataObjectAssociationType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (XMLDataObjectAssociationType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","MetaInfo").equals(reader.getName())){ + + object.setMetaInfo(MetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Content").equals(reader.getName())){ + + object.setContent(ContentRequiredRefType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignaturePropertyTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignaturePropertyTypeChoice + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localExtraElementTracker = false; + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + clearAllSettingTrackers(); + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignaturePropertyTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignaturePropertyTypeChoice", + xmlWriter); + } + + + } + if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignaturePropertyTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignaturePropertyTypeChoice object = + new SignaturePropertyTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignedInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignedInfoType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for CanonicalizationMethod + */ + + + protected CanonicalizationMethodType localCanonicalizationMethod ; + + + /** + * Auto generated getter method + * @return CanonicalizationMethodType + */ + public CanonicalizationMethodType getCanonicalizationMethod(){ + return localCanonicalizationMethod; + } + + + + /** + * Auto generated setter method + * @param param CanonicalizationMethod + */ + public void setCanonicalizationMethod(CanonicalizationMethodType param){ + + this.localCanonicalizationMethod=param; + + + } + + + /** + * field for SignatureMethod + */ + + + protected SignatureMethodType localSignatureMethod ; + + + /** + * Auto generated getter method + * @return SignatureMethodType + */ + public SignatureMethodType getSignatureMethod(){ + return localSignatureMethod; + } + + + + /** + * Auto generated setter method + * @param param SignatureMethod + */ + public void setSignatureMethod(SignatureMethodType param){ + + this.localSignatureMethod=param; + + + } + + + /** + * field for Reference + * This was an Array! + */ + + + protected ReferenceType[] localReference ; + + + /** + * Auto generated getter method + * @return ReferenceType[] + */ + public ReferenceType[] getReference(){ + return localReference; + } + + + + + + + /** + * validate the array for Reference + */ + protected void validateReference(ReferenceType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(ReferenceType[] param){ + + validateReference(param); + + + this.localReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ReferenceType + */ + public void addReference(ReferenceType param){ + if (localReference == null){ + localReference = new ReferenceType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReference); + list.add(param); + this.localReference = + (ReferenceType[])list.toArray( + new ReferenceType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignedInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignedInfoType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localCanonicalizationMethod==null){ + throw new org.apache.axis2.databinding.ADBException("CanonicalizationMethod cannot be null!!"); + } + localCanonicalizationMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","CanonicalizationMethod"), + xmlWriter); + + if (localSignatureMethod==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureMethod cannot be null!!"); + } + localSignatureMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureMethod"), + xmlWriter); + + if (localReference!=null){ + for (int i = 0;i < localReference.length;i++){ + if (localReference[i] != null){ + localReference[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "CanonicalizationMethod")); + + + if (localCanonicalizationMethod==null){ + throw new org.apache.axis2.databinding.ADBException("CanonicalizationMethod cannot be null!!"); + } + elementList.add(localCanonicalizationMethod); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignatureMethod")); + + + if (localSignatureMethod==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureMethod cannot be null!!"); + } + elementList.add(localSignatureMethod); + + if (localReference!=null) { + for (int i = 0;i < localReference.length;i++){ + + if (localReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Reference")); + elementList.add(localReference[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignedInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignedInfoType object = + new SignedInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignedInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignedInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","CanonicalizationMethod").equals(reader.getName())){ + + object.setCanonicalizationMethod(CanonicalizationMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureMethod").equals(reader.getName())){ + + object.setSignatureMethod(SignatureMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list3.add(ReferenceType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone3 = false; + while(!loopDone3){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone3 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + list3.add(ReferenceType.Factory.parse(reader)); + + }else{ + loopDone3 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReference((ReferenceType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ReferenceType.class, + list3)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyIdentifierType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifierType", + "ns2"); + + + + /** + * field for KeyIdentifierType + */ + + + protected java.lang.String localKeyIdentifierType ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getKeyIdentifierType(){ + return localKeyIdentifierType; + } + + + + /** + * Auto generated setter method + * @param param KeyIdentifierType + */ + public void setKeyIdentifierType(java.lang.String param){ + + this.localKeyIdentifierType=param; + + + } + + + public java.lang.String toString(){ + + return localKeyIdentifierType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyIdentifierType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyIdentifierType", + xmlWriter); + } + } + + if (localKeyIdentifierType==null){ + + throw new org.apache.axis2.databinding.ADBException("KeyIdentifierType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localKeyIdentifierType); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localKeyIdentifierType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static KeyIdentifierType fromString(java.lang.String value, + java.lang.String namespaceURI){ + KeyIdentifierType returnValue = new KeyIdentifierType(); + + returnValue.setKeyIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + return returnValue; + } + + public static KeyIdentifierType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return KeyIdentifierType.Factory.fromString(content,namespaceUri); + } else { + return KeyIdentifierType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyIdentifierType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyIdentifierType object = + new KeyIdentifierType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"KeyIdentifierType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setKeyIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SecureSignatureCreationDevice + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "SecureSignatureCreationDevice", + "ns2"); + + + + /** + * field for Source + * This was an Attribute! + */ + + + protected Source_type0 localSource ; + + + /** + * Auto generated getter method + * @return Source_type0 + */ + public Source_type0 getSource(){ + return localSource; + } + + + + /** + * Auto generated setter method + * @param param Source + */ + public void setSource(Source_type0 param){ + + this.localSource=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SecureSignatureCreationDevice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SecureSignatureCreationDevice", + xmlWriter); + } + + + } + + + if (localSource != null){ + writeAttribute("", + "source", + localSource.toString(), xmlWriter); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add( + new javax.xml.namespace.QName("","source")); + + attribList.add(localSource.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SecureSignatureCreationDevice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SecureSignatureCreationDevice object = + new SecureSignatureCreationDevice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SecureSignatureCreationDevice".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SecureSignatureCreationDevice)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "source" + java.lang.String tempAttribSource = + + reader.getAttributeValue(null,"source"); + + if (tempAttribSource!=null){ + java.lang.String content = tempAttribSource; + + object.setSource( + Source_type0.Factory.fromString(reader,tempAttribSource)); + + } else { + + } + handledAttributes.add("source"); + + + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ErrorResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ErrorResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ErrorCode + */ + + + protected java.math.BigInteger localErrorCode ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getErrorCode(){ + return localErrorCode; + } + + + + /** + * Auto generated setter method + * @param param ErrorCode + */ + public void setErrorCode(java.math.BigInteger param){ + + this.localErrorCode=param; + + + } + + + /** + * field for Info + */ + + + protected java.lang.String localInfo ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getInfo(){ + return localInfo; + } + + + + /** + * Auto generated setter method + * @param param Info + */ + public void setInfo(java.lang.String param){ + + this.localInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ErrorResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ErrorResponseType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "ErrorCode", xmlWriter); + + + if (localErrorCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("ErrorCode cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localErrorCode)); + + } + + xmlWriter.writeEndElement(); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Info", xmlWriter); + + + if (localInfo==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localInfo); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorCode")); + + if (localErrorCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localErrorCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("ErrorCode cannot be null!!"); + } + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info")); + + if (localInfo != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localInfo)); + } else { + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ErrorResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ErrorResponseType object = + new ErrorResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ErrorResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ErrorResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorCode").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ErrorCode" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setErrorCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Info" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setInfo( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for HMACOutputLength + */ + + + protected HMACOutputLengthType localHMACOutputLength ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localHMACOutputLengthTracker = false ; + + public boolean isHMACOutputLengthSpecified(){ + return localHMACOutputLengthTracker; + } + + + + /** + * Auto generated getter method + * @return HMACOutputLengthType + */ + public HMACOutputLengthType getHMACOutputLength(){ + return localHMACOutputLength; + } + + + + /** + * Auto generated setter method + * @param param HMACOutputLength + */ + public void setHMACOutputLength(HMACOutputLengthType param){ + localHMACOutputLengthTracker = param != null; + + this.localHMACOutputLength=param; + + + } + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureMethodType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localHMACOutputLengthTracker){ + if (localHMACOutputLength==null){ + throw new org.apache.axis2.databinding.ADBException("HMACOutputLength cannot be null!!"); + } + localHMACOutputLength.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","HMACOutputLength"), + xmlWriter); + } if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localHMACOutputLengthTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "HMACOutputLength")); + + + if (localHMACOutputLength==null){ + throw new org.apache.axis2.databinding.ADBException("HMACOutputLength cannot be null!!"); + } + elementList.add(localHMACOutputLength); + } if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureMethodType object = + new SignatureMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","HMACOutputLength").equals(reader.getName())){ + + object.setHMACOutputLength(HMACOutputLengthType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone2=false; + + while (!loopDone2){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder2 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list2.add(builder2.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone2 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone2 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Reference + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Reference", + "ns1"); + + + + /** + * field for Reference + */ + + + protected ReferenceType localReference ; + + + /** + * Auto generated getter method + * @return ReferenceType + */ + public ReferenceType getReference(){ + return localReference; + } + + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(ReferenceType param){ + + this.localReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localReference==null){ + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!"); + } + localReference.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localReference.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Reference parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Reference object = + new Reference(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + + object.setReference(ReferenceType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for TransformTypeChoice + * This was an Array! + */ + + + protected TransformTypeChoice[] localTransformTypeChoice ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformTypeChoiceTracker = false ; + + public boolean isTransformTypeChoiceSpecified(){ + return localTransformTypeChoiceTracker; + } + + + + /** + * Auto generated getter method + * @return TransformTypeChoice[] + */ + public TransformTypeChoice[] getTransformTypeChoice(){ + return localTransformTypeChoice; + } + + + + + + + /** + * validate the array for TransformTypeChoice + */ + protected void validateTransformTypeChoice(TransformTypeChoice[] param){ + + } + + + /** + * Auto generated setter method + * @param param TransformTypeChoice + */ + public void setTransformTypeChoice(TransformTypeChoice[] param){ + + validateTransformTypeChoice(param); + + localTransformTypeChoiceTracker = param != null; + + this.localTransformTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param TransformTypeChoice + */ + public void addTransformTypeChoice(TransformTypeChoice param){ + if (localTransformTypeChoice == null){ + localTransformTypeChoice = new TransformTypeChoice[]{}; + } + + + //update the setting tracker + localTransformTypeChoiceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localTransformTypeChoice); + list.add(param); + this.localTransformTypeChoice = + (TransformTypeChoice[])list.toArray( + new TransformTypeChoice[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localTransformTypeChoiceTracker){ + + if (localTransformTypeChoice!=null){ + for (int i = 0;i < localTransformTypeChoice.length;i++){ + if (localTransformTypeChoice[i] != null){ + localTransformTypeChoice[i].serialize(null,xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("TransformTypeChoice cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformTypeChoiceTracker){ + if (localTransformTypeChoice!=null) { + for (int i = 0;i < localTransformTypeChoice.length;i++){ + + if (localTransformTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "TransformTypeChoice")); + elementList.add(localTransformTypeChoice[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("TransformTypeChoice cannot be null!!"); + + } + + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformType object = + new TransformType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(TransformTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(TransformTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setTransformTypeChoice((TransformTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + TransformTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RetrievalMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = RetrievalMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for URI + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localURI ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getURI(){ + return localURI; + } + + + + /** + * Auto generated setter method + * @param param URI + */ + public void setURI(org.apache.axis2.databinding.types.URI param){ + + this.localURI=param; + + + } + + + /** + * field for Type + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getType(){ + return localType; + } + + + + /** + * Auto generated setter method + * @param param Type + */ + public void setType(org.apache.axis2.databinding.types.URI param){ + + this.localType=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":RetrievalMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "RetrievalMethodType", + xmlWriter); + } + + + } + + if (localURI != null){ + + writeAttribute("", + "URI", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI), xmlWriter); + + + } + + if (localType != null){ + + writeAttribute("", + "Type", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType), xmlWriter); + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } + attribList.add( + new javax.xml.namespace.QName("","URI")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI)); + + attribList.add( + new javax.xml.namespace.QName("","Type")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RetrievalMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RetrievalMethodType object = + new RetrievalMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"RetrievalMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (RetrievalMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "URI" + java.lang.String tempAttribURI = + + reader.getAttributeValue(null,"URI"); + + if (tempAttribURI!=null){ + java.lang.String content = tempAttribURI; + + object.setURI( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribURI)); + + } else { + + } + handledAttributes.add("URI"); + + // handle attribute "Type" + java.lang.String tempAttribType = + + reader.getAttributeValue(null,"Type"); + + if (tempAttribType!=null){ + java.lang.String content = tempAttribType; + + object.setType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribType)); + + } else { + + } + handledAttributes.add("Type"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignaturePropertyType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignaturePropertyType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SignaturePropertyTypeChoice + * This was an Array! + */ + + + protected SignaturePropertyTypeChoice[] localSignaturePropertyTypeChoice ; + + + /** + * Auto generated getter method + * @return SignaturePropertyTypeChoice[] + */ + public SignaturePropertyTypeChoice[] getSignaturePropertyTypeChoice(){ + return localSignaturePropertyTypeChoice; + } + + + + + + + /** + * validate the array for SignaturePropertyTypeChoice + */ + protected void validateSignaturePropertyTypeChoice(SignaturePropertyTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SignaturePropertyTypeChoice + */ + public void setSignaturePropertyTypeChoice(SignaturePropertyTypeChoice[] param){ + + validateSignaturePropertyTypeChoice(param); + + + this.localSignaturePropertyTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SignaturePropertyTypeChoice + */ + public void addSignaturePropertyTypeChoice(SignaturePropertyTypeChoice param){ + if (localSignaturePropertyTypeChoice == null){ + localSignaturePropertyTypeChoice = new SignaturePropertyTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSignaturePropertyTypeChoice); + list.add(param); + this.localSignaturePropertyTypeChoice = + (SignaturePropertyTypeChoice[])list.toArray( + new SignaturePropertyTypeChoice[list.size()]); + + } + + + /** + * field for Target + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localTarget ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getTarget(){ + return localTarget; + } + + + + /** + * Auto generated setter method + * @param param Target + */ + public void setTarget(org.apache.axis2.databinding.types.URI param){ + + this.localTarget=param; + + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignaturePropertyType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignaturePropertyType", + xmlWriter); + } + + + } + + if (localTarget != null){ + + writeAttribute("", + "Target", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTarget), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localTarget is null"); + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + + if (localSignaturePropertyTypeChoice!=null){ + for (int i = 0;i < localSignaturePropertyTypeChoice.length;i++){ + if (localSignaturePropertyTypeChoice[i] != null){ + localSignaturePropertyTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localSignaturePropertyTypeChoice!=null) { + for (int i = 0;i < localSignaturePropertyTypeChoice.length;i++){ + + if (localSignaturePropertyTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SignaturePropertyTypeChoice")); + elementList.add(localSignaturePropertyTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SignaturePropertyTypeChoice cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Target")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTarget)); + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignaturePropertyType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignaturePropertyType object = + new SignaturePropertyType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignaturePropertyType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignaturePropertyType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Target" + java.lang.String tempAttribTarget = + + reader.getAttributeValue(null,"Target"); + + if (tempAttribTarget!=null){ + java.lang.String content = tempAttribTarget; + + object.setTarget( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribTarget)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Target is missing"); + + } + handledAttributes.add("Target"); + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(SignaturePropertyTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(SignaturePropertyTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setSignaturePropertyTypeChoice((SignaturePropertyTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SignaturePropertyTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureEnvironmentProfile_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureEnvironmentProfile_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateSignatureLocation + */ + + + protected CreateSignatureLocationType localCreateSignatureLocation ; + + + /** + * Auto generated getter method + * @return CreateSignatureLocationType + */ + public CreateSignatureLocationType getCreateSignatureLocation(){ + return localCreateSignatureLocation; + } + + + + /** + * Auto generated setter method + * @param param CreateSignatureLocation + */ + public void setCreateSignatureLocation(CreateSignatureLocationType param){ + + this.localCreateSignatureLocation=param; + + + } + + + /** + * field for Supplement + * This was an Array! + */ + + + protected XMLDataObjectAssociationType[] localSupplement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementTracker = false ; + + public boolean isSupplementSpecified(){ + return localSupplementTracker; + } + + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType[] + */ + public XMLDataObjectAssociationType[] getSupplement(){ + return localSupplement; + } + + + + + + + /** + * validate the array for Supplement + */ + protected void validateSupplement(XMLDataObjectAssociationType[] param){ + + } + + + /** + * Auto generated setter method + * @param param Supplement + */ + public void setSupplement(XMLDataObjectAssociationType[] param){ + + validateSupplement(param); + + localSupplementTracker = param != null; + + this.localSupplement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param XMLDataObjectAssociationType + */ + public void addSupplement(XMLDataObjectAssociationType param){ + if (localSupplement == null){ + localSupplement = new XMLDataObjectAssociationType[]{}; + } + + + //update the setting tracker + localSupplementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSupplement); + list.add(param); + this.localSupplement = + (XMLDataObjectAssociationType[])list.toArray( + new XMLDataObjectAssociationType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureEnvironmentProfile_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureEnvironmentProfile_type0", + xmlWriter); + } + + + } + + if (localCreateSignatureLocation==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureLocation cannot be null!!"); + } + localCreateSignatureLocation.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureLocation"), + xmlWriter); + if (localSupplementTracker){ + if (localSupplement!=null){ + for (int i = 0;i < localSupplement.length;i++){ + if (localSupplement[i] != null){ + localSupplement[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateSignatureLocation")); + + + if (localCreateSignatureLocation==null){ + throw new org.apache.axis2.databinding.ADBException("CreateSignatureLocation cannot be null!!"); + } + elementList.add(localCreateSignatureLocation); + if (localSupplementTracker){ + if (localSupplement!=null) { + for (int i = 0;i < localSupplement.length;i++){ + + if (localSupplement[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Supplement")); + elementList.add(localSupplement[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureEnvironmentProfile_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureEnvironmentProfile_type0 object = + new CreateSignatureEnvironmentProfile_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateSignatureEnvironmentProfile_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateSignatureEnvironmentProfile_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateSignatureLocation").equals(reader.getName())){ + + object.setCreateSignatureLocation(CreateSignatureLocationType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSupplement((XMLDataObjectAssociationType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + XMLDataObjectAssociationType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Structure_type1 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "Structure_type1", + "ns2"); + + + + /** + * field for Structure_type1 + */ + + + protected java.lang.String localStructure_type1 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Structure_type1(java.lang.String value, boolean isRegisterValue) { + localStructure_type1 = value; + if (isRegisterValue){ + + _table_.put(localStructure_type1, this); + + } + + } + + public static final java.lang.String _detached = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("detached"); + + public static final java.lang.String _enveloping = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("enveloping"); + + public static final Structure_type1 detached = + new Structure_type1(_detached,true); + + public static final Structure_type1 enveloping = + new Structure_type1(_enveloping,true); + + + public java.lang.String getValue() { return localStructure_type1;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localStructure_type1.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":Structure_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "Structure_type1", + xmlWriter); + } + } + + if (localStructure_type1==null){ + + throw new org.apache.axis2.databinding.ADBException("Structure_type1 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localStructure_type1); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStructure_type1) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Structure_type1 fromValue(java.lang.String value) + throws java.lang.IllegalArgumentException { + Structure_type1 enumeration = (Structure_type1) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Structure_type1 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Structure_type1 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Structure_type1.Factory.fromString(content,namespaceUri); + } else { + return Structure_type1.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Structure_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Structure_type1 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Structure_type1" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Structure_type1.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Structure_type1.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class InputDataType extends ContentExLocRefBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = InputDataType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for PartOf + * This was an Attribute! + */ + + + protected PartOf_type0 localPartOf ; + + + /** + * Auto generated getter method + * @return PartOf_type0 + */ + public PartOf_type0 getPartOf(){ + return localPartOf; + } + + + + /** + * Auto generated setter method + * @param param PartOf + */ + public void setPartOf(PartOf_type0 param){ + + this.localPartOf=param; + + + } + + + /** + * field for ReferringSigReference + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localReferringSigReference ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getReferringSigReference(){ + return localReferringSigReference; + } + + + + /** + * Auto generated setter method + * @param param ReferringSigReference + */ + public void setReferringSigReference(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localReferringSigReference=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":InputDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "InputDataType", + xmlWriter); + } + + + + if (localPartOf != null){ + writeAttribute("", + "PartOf", + localPartOf.toString(), xmlWriter); + } + + if (localReferringSigReference != null){ + + writeAttribute("", + "ReferringSigReference", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference), xmlWriter); + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","InputDataType")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","PartOf")); + + attribList.add(localPartOf.toString()); + + attribList.add( + new javax.xml.namespace.QName("","ReferringSigReference")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReferringSigReference)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static InputDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + InputDataType object = + new InputDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"InputDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (InputDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "PartOf" + java.lang.String tempAttribPartOf = + + reader.getAttributeValue(null,"PartOf"); + + if (tempAttribPartOf!=null){ + java.lang.String content = tempAttribPartOf; + + object.setPartOf( + PartOf_type0.Factory.fromString(reader,tempAttribPartOf)); + + } else { + + } + handledAttributes.add("PartOf"); + + // handle attribute "ReferringSigReference" + java.lang.String tempAttribReferringSigReference = + + reader.getAttributeValue(null,"ReferringSigReference"); + + if (tempAttribReferringSigReference!=null){ + java.lang.String content = tempAttribReferringSigReference; + + object.setReferringSigReference( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(tempAttribReferringSigReference)); + + } else { + + } + handledAttributes.add("ReferringSigReference"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Structure_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "Structure_type0", + "ns2"); + + + + /** + * field for Structure_type0 + */ + + + protected java.lang.String localStructure_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Structure_type0(java.lang.String value, boolean isRegisterValue) { + localStructure_type0 = value; + if (isRegisterValue){ + + _table_.put(localStructure_type0, this); + + } + + } + + public static final java.lang.String _detached = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("detached"); + + public static final java.lang.String _enveloping = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("enveloping"); + + public static final Structure_type0 detached = + new Structure_type0(_detached,true); + + public static final Structure_type0 enveloping = + new Structure_type0(_enveloping,true); + + + public java.lang.String getValue() { return localStructure_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localStructure_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":Structure_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "Structure_type0", + xmlWriter); + } + } + + if (localStructure_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("Structure_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localStructure_type0); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localStructure_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Structure_type0 fromValue(java.lang.String value) + throws java.lang.IllegalArgumentException { + Structure_type0 enumeration = (Structure_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Structure_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Structure_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Structure_type0.Factory.fromString(content,namespaceUri); + } else { + return Structure_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Structure_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Structure_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Structure_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Structure_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Structure_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureEnvironment_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureEnvironment_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureEnvironment_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureEnvironment_type0", + xmlWriter); + } + + + } + + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureEnvironment_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureEnvironment_type0 object = + new SignatureEnvironment_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureEnvironment_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureEnvironment_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname1 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname1); + object.setExtraElement(builder1.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class RSAKeyValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "RSAKeyValue", + "ns1"); + + + + /** + * field for RSAKeyValue + */ + + + protected RSAKeyValueType localRSAKeyValue ; + + + /** + * Auto generated getter method + * @return RSAKeyValueType + */ + public RSAKeyValueType getRSAKeyValue(){ + return localRSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param RSAKeyValue + */ + public void setRSAKeyValue(RSAKeyValueType param){ + + this.localRSAKeyValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localRSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("RSAKeyValue cannot be null!"); + } + localRSAKeyValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localRSAKeyValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static RSAKeyValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + RSAKeyValue object = + new RSAKeyValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","RSAKeyValue").equals(reader.getName())){ + + object.setRSAKeyValue(RSAKeyValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestValueType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DigestValueType", + "ns1"); + + + + /** + * field for DigestValueType + */ + + + protected javax.activation.DataHandler localDigestValueType ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getDigestValueType(){ + return localDigestValueType; + } + + + + /** + * Auto generated setter method + * @param param DigestValueType + */ + public void setDigestValueType(javax.activation.DataHandler param){ + + this.localDigestValueType=param; + + + } + + + public java.lang.String toString(){ + + return localDigestValueType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DigestValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DigestValueType", + xmlWriter); + } + } + + if (localDigestValueType==null){ + + throw new org.apache.axis2.databinding.ADBException("DigestValueType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDigestValueType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDigestValueType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static DigestValueType fromString(java.lang.String value, + java.lang.String namespaceURI){ + DigestValueType returnValue = new DigestValueType(); + + returnValue.setDigestValueType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(value)); + + + return returnValue; + } + + public static DigestValueType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return DigestValueType.Factory.fromString(content,namespaceUri); + } else { + return DigestValueType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestValueType object = + new DigestValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DigestValueType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDigestValueType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Signature + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Signature", + "ns1"); + + + + /** + * field for Signature + */ + + + protected SignatureType localSignature ; + + + /** + * Auto generated getter method + * @return SignatureType + */ + public SignatureType getSignature(){ + return localSignature; + } + + + + /** + * Auto generated setter method + * @param param Signature + */ + public void setSignature(SignatureType param){ + + this.localSignature=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignature==null){ + throw new org.apache.axis2.databinding.ADBException("Signature cannot be null!"); + } + localSignature.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignature.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Signature parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Signature object = + new Signature(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Signature").equals(reader.getName())){ + + object.setSignature(SignatureType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfo_type1 extends CMSDataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfo_type1 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfo_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfo_type1", + xmlWriter); + } + + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo_type1")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfo_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfo_type1 object = + new DataObjectInfo_type1(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObjectInfo_type1".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObjectInfo_type1)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type1.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type1.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DataObjectInfo_type0 extends DataObjectInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DataObjectInfo_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for ChildOfManifest + * This was an Attribute! + */ + + + protected boolean localChildOfManifest = + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean("false"); + + + /** + * Auto generated getter method + * @return boolean + */ + public boolean getChildOfManifest(){ + return localChildOfManifest; + } + + + + /** + * Auto generated setter method + * @param param ChildOfManifest + */ + public void setChildOfManifest(boolean param){ + + this.localChildOfManifest=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DataObjectInfo_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DataObjectInfo_type0", + xmlWriter); + } + + + + if (localStructure != null){ + writeAttribute("", + "Structure", + localStructure.toString(), xmlWriter); + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localStructure is null"); + } + + if (true) { + + writeAttribute("", + "ChildOfManifest", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localChildOfManifest), xmlWriter); + + + } + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + localDataObject.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject"), + xmlWriter); + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + localDataObjectInfoTypeChoice_type0.serialize(null,xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + attribList.add(new javax.xml.namespace.QName("http://www.w3.org/2001/XMLSchema-instance","type")); + attribList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObjectInfo_type0")); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObject")); + + + if (localDataObject==null){ + throw new org.apache.axis2.databinding.ADBException("DataObject cannot be null!!"); + } + elementList.add(localDataObject); + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DataObjectInfoTypeChoice_type0")); + + + if (localDataObjectInfoTypeChoice_type0==null){ + throw new org.apache.axis2.databinding.ADBException("DataObjectInfoTypeChoice_type0 cannot be null!!"); + } + elementList.add(localDataObjectInfoTypeChoice_type0); + + attribList.add( + new javax.xml.namespace.QName("","Structure")); + + attribList.add(localStructure.toString()); + + attribList.add( + new javax.xml.namespace.QName("","ChildOfManifest")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localChildOfManifest)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DataObjectInfo_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DataObjectInfo_type0 object = + new DataObjectInfo_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DataObjectInfo_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DataObjectInfo_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Structure" + java.lang.String tempAttribStructure = + + reader.getAttributeValue(null,"Structure"); + + if (tempAttribStructure!=null){ + java.lang.String content = tempAttribStructure; + + object.setStructure( + Structure_type0.Factory.fromString(reader,tempAttribStructure)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Structure is missing"); + + } + handledAttributes.add("Structure"); + + // handle attribute "ChildOfManifest" + java.lang.String tempAttribChildOfManifest = + + reader.getAttributeValue(null,"ChildOfManifest"); + + if (tempAttribChildOfManifest!=null){ + java.lang.String content = tempAttribChildOfManifest; + + object.setChildOfManifest( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBoolean(tempAttribChildOfManifest)); + + } else { + + } + handledAttributes.add("ChildOfManifest"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DataObject").equals(reader.getName())){ + + object.setDataObject(DataObject_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() ){ + + object.setDataObjectInfoTypeChoice_type0(DataObjectInfoTypeChoice_type0.Factory.parse(reader)); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DSAKeyValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DSAKeyValue", + "ns1"); + + + + /** + * field for DSAKeyValue + */ + + + protected DSAKeyValueType localDSAKeyValue ; + + + /** + * Auto generated getter method + * @return DSAKeyValueType + */ + public DSAKeyValueType getDSAKeyValue(){ + return localDSAKeyValue; + } + + + + /** + * Auto generated setter method + * @param param DSAKeyValue + */ + public void setDSAKeyValue(DSAKeyValueType param){ + + this.localDSAKeyValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localDSAKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("DSAKeyValue cannot be null!"); + } + localDSAKeyValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localDSAKeyValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DSAKeyValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DSAKeyValue object = + new DSAKeyValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DSAKeyValue").equals(reader.getName())){ + + object.setDSAKeyValue(DSAKeyValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ReferenceType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ReferenceType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for DigestMethod + */ + + + protected DigestMethodType localDigestMethod ; + + + /** + * Auto generated getter method + * @return DigestMethodType + */ + public DigestMethodType getDigestMethod(){ + return localDigestMethod; + } + + + + /** + * Auto generated setter method + * @param param DigestMethod + */ + public void setDigestMethod(DigestMethodType param){ + + this.localDigestMethod=param; + + + } + + + /** + * field for DigestValue + */ + + + protected DigestValueType localDigestValue ; + + + /** + * Auto generated getter method + * @return DigestValueType + */ + public DigestValueType getDigestValue(){ + return localDigestValue; + } + + + + /** + * Auto generated setter method + * @param param DigestValue + */ + public void setDigestValue(DigestValueType param){ + + this.localDigestValue=param; + + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + /** + * field for URI + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localURI ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getURI(){ + return localURI; + } + + + + /** + * Auto generated setter method + * @param param URI + */ + public void setURI(org.apache.axis2.databinding.types.URI param){ + + this.localURI=param; + + + } + + + /** + * field for Type + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getType(){ + return localType; + } + + + + /** + * Auto generated setter method + * @param param Type + */ + public void setType(org.apache.axis2.databinding.types.URI param){ + + this.localType=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ReferenceType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ReferenceType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localURI != null){ + + writeAttribute("", + "URI", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI), xmlWriter); + + + } + + if (localType != null){ + + writeAttribute("", + "Type", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType), xmlWriter); + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + localDigestMethod.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod"), + xmlWriter); + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + localDigestValue.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestMethod")); + + + if (localDigestMethod==null){ + throw new org.apache.axis2.databinding.ADBException("DigestMethod cannot be null!!"); + } + elementList.add(localDigestMethod); + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "DigestValue")); + + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!!"); + } + elementList.add(localDigestValue); + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + attribList.add( + new javax.xml.namespace.QName("","URI")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI)); + + attribList.add( + new javax.xml.namespace.QName("","Type")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localType)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ReferenceType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ReferenceType object = + new ReferenceType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ReferenceType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ReferenceType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + // handle attribute "URI" + java.lang.String tempAttribURI = + + reader.getAttributeValue(null,"URI"); + + if (tempAttribURI!=null){ + java.lang.String content = tempAttribURI; + + object.setURI( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribURI)); + + } else { + + } + handledAttributes.add("URI"); + + // handle attribute "Type" + java.lang.String tempAttribType = + + reader.getAttributeValue(null,"Type"); + + if (tempAttribType!=null){ + java.lang.String content = tempAttribType; + + object.setType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribType)); + + } else { + + } + handledAttributes.add("Type"); + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestMethod").equals(reader.getName())){ + + object.setDigestMethod(DigestMethodType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue").equals(reader.getName())){ + + object.setDigestValue(DigestValueType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = KeyInfoType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for KeyInfoTypeChoice + * This was an Array! + */ + + + protected KeyInfoTypeChoice[] localKeyInfoTypeChoice ; + + + /** + * Auto generated getter method + * @return KeyInfoTypeChoice[] + */ + public KeyInfoTypeChoice[] getKeyInfoTypeChoice(){ + return localKeyInfoTypeChoice; + } + + + + + + + /** + * validate the array for KeyInfoTypeChoice + */ + protected void validateKeyInfoTypeChoice(KeyInfoTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param KeyInfoTypeChoice + */ + public void setKeyInfoTypeChoice(KeyInfoTypeChoice[] param){ + + validateKeyInfoTypeChoice(param); + + + this.localKeyInfoTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param KeyInfoTypeChoice + */ + public void addKeyInfoTypeChoice(KeyInfoTypeChoice param){ + if (localKeyInfoTypeChoice == null){ + localKeyInfoTypeChoice = new KeyInfoTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localKeyInfoTypeChoice); + list.add(param); + this.localKeyInfoTypeChoice = + (KeyInfoTypeChoice[])list.toArray( + new KeyInfoTypeChoice[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":KeyInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "KeyInfoType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + + if (localKeyInfoTypeChoice!=null){ + for (int i = 0;i < localKeyInfoTypeChoice.length;i++){ + if (localKeyInfoTypeChoice[i] != null){ + localKeyInfoTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localKeyInfoTypeChoice!=null) { + for (int i = 0;i < localKeyInfoTypeChoice.length;i++){ + + if (localKeyInfoTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "KeyInfoTypeChoice")); + elementList.add(localKeyInfoTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("KeyInfoTypeChoice cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyInfoType object = + new KeyInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"KeyInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (KeyInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(KeyInfoTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(KeyInfoTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setKeyInfoTypeChoice((KeyInfoTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + KeyInfoTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsDataType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyTransformsDataType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for VerifyTransformsDataTypeChoice + * This was an Array! + */ + + + protected VerifyTransformsDataTypeChoice[] localVerifyTransformsDataTypeChoice ; + + + /** + * Auto generated getter method + * @return VerifyTransformsDataTypeChoice[] + */ + public VerifyTransformsDataTypeChoice[] getVerifyTransformsDataTypeChoice(){ + return localVerifyTransformsDataTypeChoice; + } + + + + + + + /** + * validate the array for VerifyTransformsDataTypeChoice + */ + protected void validateVerifyTransformsDataTypeChoice(VerifyTransformsDataTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param VerifyTransformsDataTypeChoice + */ + public void setVerifyTransformsDataTypeChoice(VerifyTransformsDataTypeChoice[] param){ + + validateVerifyTransformsDataTypeChoice(param); + + + this.localVerifyTransformsDataTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyTransformsDataTypeChoice + */ + public void addVerifyTransformsDataTypeChoice(VerifyTransformsDataTypeChoice param){ + if (localVerifyTransformsDataTypeChoice == null){ + localVerifyTransformsDataTypeChoice = new VerifyTransformsDataTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localVerifyTransformsDataTypeChoice); + list.add(param); + this.localVerifyTransformsDataTypeChoice = + (VerifyTransformsDataTypeChoice[])list.toArray( + new VerifyTransformsDataTypeChoice[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyTransformsDataType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyTransformsDataType", + xmlWriter); + } + + + } + + + if (localVerifyTransformsDataTypeChoice!=null){ + for (int i = 0;i < localVerifyTransformsDataTypeChoice.length;i++){ + if (localVerifyTransformsDataTypeChoice[i] != null){ + localVerifyTransformsDataTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localVerifyTransformsDataTypeChoice!=null) { + for (int i = 0;i < localVerifyTransformsDataTypeChoice.length;i++){ + + if (localVerifyTransformsDataTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsDataTypeChoice")); + elementList.add(localVerifyTransformsDataTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsDataTypeChoice cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsDataType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsDataType object = + new VerifyTransformsDataType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyTransformsDataType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyTransformsDataType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(VerifyTransformsDataTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(VerifyTransformsDataTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setVerifyTransformsDataTypeChoice((VerifyTransformsDataTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyTransformsDataTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestMethodType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = DigestMethodType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ExtraElement + * This was an Array! + */ + + + protected org.apache.axiom.om.OMElement[] localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement[] + */ + public org.apache.axiom.om.OMElement[] getExtraElement(){ + return localExtraElement; + } + + + + + + + /** + * validate the array for ExtraElement + */ + protected void validateExtraElement(org.apache.axiom.om.OMElement[] param){ + + } + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement[] param){ + + validateExtraElement(param); + + localExtraElementTracker = param != null; + + this.localExtraElement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param org.apache.axiom.om.OMElement + */ + public void addExtraElement(org.apache.axiom.om.OMElement param){ + if (localExtraElement == null){ + localExtraElement = new org.apache.axiom.om.OMElement[]{}; + } + + + //update the setting tracker + localExtraElementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localExtraElement); + list.add(param); + this.localExtraElement = + (org.apache.axiom.om.OMElement[])list.toArray( + new org.apache.axiom.om.OMElement[list.size()]); + + } + + + /** + * field for Algorithm + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localAlgorithm ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getAlgorithm(){ + return localAlgorithm; + } + + + + /** + * Auto generated setter method + * @param param Algorithm + */ + public void setAlgorithm(org.apache.axis2.databinding.types.URI param){ + + this.localAlgorithm=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":DigestMethodType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "DigestMethodType", + xmlWriter); + } + + + } + + if (localAlgorithm != null){ + + writeAttribute("", + "Algorithm", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localAlgorithm is null"); + } + if (localExtraElementTracker){ + + if (localExtraElement != null){ + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + localExtraElement[i].serialize(xmlWriter); + } else { + + // we have to do nothing since minOccures zero + + } + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localExtraElementTracker){ + if (localExtraElement != null) { + for (int i = 0;i < localExtraElement.length;i++){ + if (localExtraElement[i] != null){ + elementList.add(new javax.xml.namespace.QName("", + "extraElement")); + elementList.add( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localExtraElement[i])); + } else { + + // have to do nothing + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + attribList.add( + new javax.xml.namespace.QName("","Algorithm")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAlgorithm)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestMethodType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestMethodType object = + new DigestMethodType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"DigestMethodType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (DigestMethodType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Algorithm" + java.lang.String tempAttribAlgorithm = + + reader.getAttributeValue(null,"Algorithm"); + + if (tempAttribAlgorithm!=null){ + java.lang.String content = tempAttribAlgorithm; + + object.setAlgorithm( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribAlgorithm)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Algorithm is missing"); + + } + handledAttributes.add("Algorithm"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + // Process the array and step past its final element's end. + + boolean loopDone1=false; + + while (!loopDone1){ + event = reader.getEventType(); + if (javax.xml.stream.XMLStreamConstants.START_ELEMENT == event){ + + // We need to wrap the reader so that it produces a fake START_DOCUEMENT event + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder1 + = new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader), reader.getName()); + + list1.add(builder1.getOMElement()); + reader.next(); + if (reader.isEndElement()) { + // we have two countinuos end elements + loopDone1 = true; + } + + }else if (javax.xml.stream.XMLStreamConstants.END_ELEMENT == event){ + loopDone1 = true; + }else{ + reader.next(); + } + + } + + + object.setExtraElement((org.apache.axiom.om.OMElement[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + org.apache.axiom.om.OMElement.class,list1)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class AllSignatoriesType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "AllSignatoriesType", + "ns2"); + + + + /** + * field for AllSignatoriesType + */ + + + protected java.lang.String localAllSignatoriesType ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected AllSignatoriesType(java.lang.String value, boolean isRegisterValue) { + localAllSignatoriesType = value; + if (isRegisterValue){ + + _table_.put(localAllSignatoriesType, this); + + } + + } + + public static final java.lang.String _all = + org.apache.axis2.databinding.utils.ConverterUtil.convertToString("all"); + + public static final AllSignatoriesType all = + new AllSignatoriesType(_all,true); + + + public java.lang.String getValue() { return localAllSignatoriesType;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localAllSignatoriesType.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":AllSignatoriesType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "AllSignatoriesType", + xmlWriter); + } + } + + if (localAllSignatoriesType==null){ + + throw new org.apache.axis2.databinding.ADBException("AllSignatoriesType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(localAllSignatoriesType); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localAllSignatoriesType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static AllSignatoriesType fromValue(java.lang.String value) + throws java.lang.IllegalArgumentException { + AllSignatoriesType enumeration = (AllSignatoriesType) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static AllSignatoriesType fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static AllSignatoriesType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return AllSignatoriesType.Factory.fromString(content,namespaceUri); + } else { + return AllSignatoriesType.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static AllSignatoriesType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + AllSignatoriesType object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"AllSignatoriesType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = AllSignatoriesType.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = AllSignatoriesType.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformsInfoType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformsInfoType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Transforms + */ + + + protected TransformsType localTransforms ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localTransformsTracker = false ; + + public boolean isTransformsSpecified(){ + return localTransformsTracker; + } + + + + /** + * Auto generated getter method + * @return TransformsType + */ + public TransformsType getTransforms(){ + return localTransforms; + } + + + + /** + * Auto generated setter method + * @param param Transforms + */ + public void setTransforms(TransformsType param){ + localTransformsTracker = param != null; + + this.localTransforms=param; + + + } + + + /** + * field for FinalDataMetaInfo + */ + + + protected FinalDataMetaInfoType localFinalDataMetaInfo ; + + + /** + * Auto generated getter method + * @return FinalDataMetaInfoType + */ + public FinalDataMetaInfoType getFinalDataMetaInfo(){ + return localFinalDataMetaInfo; + } + + + + /** + * Auto generated setter method + * @param param FinalDataMetaInfo + */ + public void setFinalDataMetaInfo(FinalDataMetaInfoType param){ + + this.localFinalDataMetaInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformsInfoType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformsInfoType", + xmlWriter); + } + + + } + if (localTransformsTracker){ + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + localTransforms.serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms"), + xmlWriter); + } + if (localFinalDataMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("FinalDataMetaInfo cannot be null!!"); + } + localFinalDataMetaInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FinalDataMetaInfo"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localTransformsTracker){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transforms")); + + + if (localTransforms==null){ + throw new org.apache.axis2.databinding.ADBException("Transforms cannot be null!!"); + } + elementList.add(localTransforms); + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "FinalDataMetaInfo")); + + + if (localFinalDataMetaInfo==null){ + throw new org.apache.axis2.databinding.ADBException("FinalDataMetaInfo cannot be null!!"); + } + elementList.add(localFinalDataMetaInfo); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformsInfoType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformsInfoType object = + new TransformsInfoType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformsInfoType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformsInfoType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transforms").equals(reader.getName())){ + + object.setTransforms(TransformsType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","FinalDataMetaInfo").equals(reader.getName())){ + + object.setFinalDataMetaInfo(FinalDataMetaInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ContentExLocRefBaseType extends ContentBaseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ContentExLocRefBaseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localXMLContentTracker = false; + + localLocRefContentTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for XMLContent + */ + + + protected XMLContentType localXMLContent ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localXMLContentTracker = false ; + + public boolean isXMLContentSpecified(){ + return localXMLContentTracker; + } + + + + /** + * Auto generated getter method + * @return XMLContentType + */ + public XMLContentType getXMLContent(){ + return localXMLContent; + } + + + + /** + * Auto generated setter method + * @param param XMLContent + */ + public void setXMLContent(XMLContentType param){ + + clearAllSettingTrackers(); + localXMLContentTracker = param != null; + + this.localXMLContent=param; + + + } + + + /** + * Auto generated getter method + * Overridden from ContentBaseType + * + * @throws RuntimeException + */ + public org.apache.axis2.databinding.types.URI getLocRefContent(){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + /** + * Auto generated setter method + * Overridden from ContentBaseType + * + * @param param LocRefContent + * @throws RuntimeException + */ + public void setLocRefContent(org.apache.axis2.databinding.types.URI param){ + throw new java.lang.RuntimeException("The property has been removed by restriction"); + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ContentExLocRefBaseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ContentExLocRefBaseType", + xmlWriter); + } + + + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localXMLContentTracker){ + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + localXMLContent.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent"), + xmlWriter); + } if (localLocRefContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "LocRefContent", xmlWriter); + + + if (localLocRefContent==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + + } + + xmlWriter.writeEndElement(); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localXMLContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "XMLContent")); + + + if (localXMLContent==null){ + throw new org.apache.axis2.databinding.ADBException("XMLContent cannot be null!!"); + } + elementList.add(localXMLContent); + } if (localLocRefContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "LocRefContent")); + + if (localLocRefContent != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localLocRefContent)); + } else { + throw new org.apache.axis2.databinding.ADBException("LocRefContent cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ContentExLocRefBaseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ContentExLocRefBaseType object = + new ContentExLocRefBaseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ContentExLocRefBaseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ContentExLocRefBaseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","XMLContent").equals(reader.getName())){ + + object.setXMLContent(XMLContentType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","LocRefContent").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"LocRefContent" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setLocRefContent( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(content)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateXMLSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for KeyIdentifier + */ + + + protected KeyIdentifierType localKeyIdentifier ; + + + /** + * Auto generated getter method + * @return KeyIdentifierType + */ + public KeyIdentifierType getKeyIdentifier(){ + return localKeyIdentifier; + } + + + + /** + * Auto generated setter method + * @param param KeyIdentifier + */ + public void setKeyIdentifier(KeyIdentifierType param){ + + this.localKeyIdentifier=param; + + + } + + + /** + * field for SingleSignatureInfo + * This was an Array! + */ + + + protected SingleSignatureInfo_type0[] localSingleSignatureInfo ; + + + /** + * Auto generated getter method + * @return SingleSignatureInfo_type0[] + */ + public SingleSignatureInfo_type0[] getSingleSignatureInfo(){ + return localSingleSignatureInfo; + } + + + + + + + /** + * validate the array for SingleSignatureInfo + */ + protected void validateSingleSignatureInfo(SingleSignatureInfo_type0[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param SingleSignatureInfo + */ + public void setSingleSignatureInfo(SingleSignatureInfo_type0[] param){ + + validateSingleSignatureInfo(param); + + + this.localSingleSignatureInfo=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param SingleSignatureInfo_type0 + */ + public void addSingleSignatureInfo(SingleSignatureInfo_type0 param){ + if (localSingleSignatureInfo == null){ + localSingleSignatureInfo = new SingleSignatureInfo_type0[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSingleSignatureInfo); + list.add(param); + this.localSingleSignatureInfo = + (SingleSignatureInfo_type0[])list.toArray( + new SingleSignatureInfo_type0[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureRequestType", + xmlWriter); + } + + + } + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + localKeyIdentifier.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier"), + xmlWriter); + + if (localSingleSignatureInfo!=null){ + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + if (localSingleSignatureInfo[i] != null){ + localSingleSignatureInfo[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "KeyIdentifier")); + + + if (localKeyIdentifier==null){ + throw new org.apache.axis2.databinding.ADBException("KeyIdentifier cannot be null!!"); + } + elementList.add(localKeyIdentifier); + + if (localSingleSignatureInfo!=null) { + for (int i = 0;i < localSingleSignatureInfo.length;i++){ + + if (localSingleSignatureInfo[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SingleSignatureInfo")); + elementList.add(localSingleSignatureInfo[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("SingleSignatureInfo cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureRequestType object = + new CreateXMLSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateXMLSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateXMLSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","KeyIdentifier").equals(reader.getName())){ + + object.setKeyIdentifier(KeyIdentifierType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SingleSignatureInfo").equals(reader.getName())){ + list2.add(SingleSignatureInfo_type0.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSingleSignatureInfo((SingleSignatureInfo_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + SingleSignatureInfo_type0.class, + list2)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyTransformsDataTypeChoice + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyTransformsDataTypeChoice + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localVerifyTransformsInfoProfileTracker = false; + + localVerifyTransformsInfoProfileIDTracker = false; + + } + + + /** + * field for VerifyTransformsInfoProfile + */ + + + protected VerifyTransformsInfoProfile_type0 localVerifyTransformsInfoProfile ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localVerifyTransformsInfoProfileTracker = false ; + + public boolean isVerifyTransformsInfoProfileSpecified(){ + return localVerifyTransformsInfoProfileTracker; + } + + + + /** + * Auto generated getter method + * @return VerifyTransformsInfoProfile_type0 + */ + public VerifyTransformsInfoProfile_type0 getVerifyTransformsInfoProfile(){ + return localVerifyTransformsInfoProfile; + } + + + + /** + * Auto generated setter method + * @param param VerifyTransformsInfoProfile + */ + public void setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0 param){ + + clearAllSettingTrackers(); + localVerifyTransformsInfoProfileTracker = param != null; + + this.localVerifyTransformsInfoProfile=param; + + + } + + + /** + * field for VerifyTransformsInfoProfileID + */ + + + protected java.lang.String localVerifyTransformsInfoProfileID ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localVerifyTransformsInfoProfileIDTracker = false ; + + public boolean isVerifyTransformsInfoProfileIDSpecified(){ + return localVerifyTransformsInfoProfileIDTracker; + } + + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getVerifyTransformsInfoProfileID(){ + return localVerifyTransformsInfoProfileID; + } + + + + /** + * Auto generated setter method + * @param param VerifyTransformsInfoProfileID + */ + public void setVerifyTransformsInfoProfileID(java.lang.String param){ + + clearAllSettingTrackers(); + localVerifyTransformsInfoProfileIDTracker = param != null; + + this.localVerifyTransformsInfoProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyTransformsDataTypeChoice", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyTransformsDataTypeChoice", + xmlWriter); + } + + + } + if (localVerifyTransformsInfoProfileTracker){ + if (localVerifyTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfile cannot be null!!"); + } + localVerifyTransformsInfoProfile.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfile"), + xmlWriter); + } if (localVerifyTransformsInfoProfileIDTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "VerifyTransformsInfoProfileID", xmlWriter); + + + if (localVerifyTransformsInfoProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(localVerifyTransformsInfoProfileID); + + } + + xmlWriter.writeEndElement(); + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localVerifyTransformsInfoProfileTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsInfoProfile")); + + + if (localVerifyTransformsInfoProfile==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfile cannot be null!!"); + } + elementList.add(localVerifyTransformsInfoProfile); + } if (localVerifyTransformsInfoProfileIDTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyTransformsInfoProfileID")); + + if (localVerifyTransformsInfoProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localVerifyTransformsInfoProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyTransformsInfoProfileID cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyTransformsDataTypeChoice parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyTransformsDataTypeChoice object = + new VerifyTransformsDataTypeChoice(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfile").equals(reader.getName())){ + + object.setVerifyTransformsInfoProfile(VerifyTransformsInfoProfile_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyTransformsInfoProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"VerifyTransformsInfoProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setVerifyTransformsInfoProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(content)); + + reader.next(); + + } // End of if for expected property start element + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SPKIDataTypeSequence + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SPKIDataTypeSequence + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for SPKISexp + */ + + + protected javax.activation.DataHandler localSPKISexp ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getSPKISexp(){ + return localSPKISexp; + } + + + + /** + * Auto generated setter method + * @param param SPKISexp + */ + public void setSPKISexp(javax.activation.DataHandler param){ + + this.localSPKISexp=param; + + + } + + + /** + * field for ExtraElement + */ + + + protected org.apache.axiom.om.OMElement localExtraElement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localExtraElementTracker = false ; + + public boolean isExtraElementSpecified(){ + return localExtraElementTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getExtraElement(){ + return localExtraElement; + } + + + + /** + * Auto generated setter method + * @param param ExtraElement + */ + public void setExtraElement(org.apache.axiom.om.OMElement param){ + localExtraElementTracker = param != null; + + this.localExtraElement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SPKIDataTypeSequence", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SPKIDataTypeSequence", + xmlWriter); + } + + + } + + namespace = "http://www.w3.org/2000/09/xmldsig#"; + writeStartElement(null, namespace, "SPKISexp", xmlWriter); + + + if (localSPKISexp!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localSPKISexp, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for SPKISexp", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + if (localExtraElementTracker){ + + if (localExtraElement != null) { + localExtraElement.serialize(xmlWriter); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "SPKISexp")); + + elementList.add(localSPKISexp); + if (localExtraElementTracker){ + if (localExtraElement != null){ + elementList.add(org.apache.axis2.databinding.utils.Constants.OM_ELEMENT_KEY); + elementList.add(localExtraElement); + } else { + throw new org.apache.axis2.databinding.ADBException("extraElement cannot be null!!"); + } + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SPKIDataTypeSequence parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SPKIDataTypeSequence object = + new SPKIDataTypeSequence(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SPKISexp").equals(reader.getName())){ + + object.setSPKISexp(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + + + //use the QName from the parser as the name for the builder + javax.xml.namespace.QName startQname2 = reader.getName(); + + // We need to wrap the reader so that it produces a fake START_DOCUMENT event + // this is needed by the builder classes + org.apache.axis2.databinding.utils.NamedStaxOMBuilder builder2 = + new org.apache.axis2.databinding.utils.NamedStaxOMBuilder( + new org.apache.axis2.util.StreamWrapper(reader),startQname2); + object.setExtraElement(builder2.getOMElement()); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureValueType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = SignatureValueType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Base64Binary + */ + + + protected javax.activation.DataHandler localBase64Binary ; + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Binary(){ + return localBase64Binary; + } + + + + /** + * Auto generated setter method + * @param param Base64Binary + */ + public void setBase64Binary(javax.activation.DataHandler param){ + + this.localBase64Binary=param; + + + } + + + public java.lang.String toString(){ + + return localBase64Binary.toString(); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":SignatureValueType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "SignatureValueType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + + if (localBase64Binary!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Binary, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for base64Binary", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT); + + elementList.add(localBase64Binary); + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static SignatureValueType fromString(java.lang.String value, + java.lang.String namespaceURI){ + SignatureValueType returnValue = new SignatureValueType(); + + returnValue.setBase64Binary( + org.apache.axis2.databinding.utils.ConverterUtil.convertToBase64Binary(value)); + + + return returnValue; + } + + public static SignatureValueType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return SignatureValueType.Factory.fromString(content,namespaceUri); + } else { + return SignatureValueType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureValueType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureValueType object = + new SignatureValueType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"SignatureValueType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (SignatureValueType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + object.setBase64Binary(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class SignatureValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "SignatureValue", + "ns1"); + + + + /** + * field for SignatureValue + */ + + + protected SignatureValueType localSignatureValue ; + + + /** + * Auto generated getter method + * @return SignatureValueType + */ + public SignatureValueType getSignatureValue(){ + return localSignatureValue; + } + + + + /** + * Auto generated setter method + * @param param SignatureValue + */ + public void setSignatureValue(SignatureValueType param){ + + this.localSignatureValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSignatureValue==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureValue cannot be null!"); + } + localSignatureValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSignatureValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static SignatureValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + SignatureValue object = + new SignatureValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","SignatureValue").equals(reader.getName())){ + + object.setSignatureValue(SignatureValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformParameterType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformParameterType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + /** Whenever a new property is set ensure all others are unset + * There can be only one choice and the last one wins + */ + private void clearAllSettingTrackers() { + + localBase64ContentTracker = false; + + localHashTracker = false; + + } + + + /** + * field for Base64Content + */ + + + protected javax.activation.DataHandler localBase64Content ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localBase64ContentTracker = false ; + + public boolean isBase64ContentSpecified(){ + return localBase64ContentTracker; + } + + + + /** + * Auto generated getter method + * @return javax.activation.DataHandler + */ + public javax.activation.DataHandler getBase64Content(){ + return localBase64Content; + } + + + + /** + * Auto generated setter method + * @param param Base64Content + */ + public void setBase64Content(javax.activation.DataHandler param){ + + clearAllSettingTrackers(); + localBase64ContentTracker = param != null; + + this.localBase64Content=param; + + + } + + + /** + * field for Hash + */ + + + protected Hash_type0 localHash ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localHashTracker = false ; + + public boolean isHashSpecified(){ + return localHashTracker; + } + + + + /** + * Auto generated getter method + * @return Hash_type0 + */ + public Hash_type0 getHash(){ + return localHash; + } + + + + /** + * Auto generated setter method + * @param param Hash + */ + public void setHash(Hash_type0 param){ + + clearAllSettingTrackers(); + localHashTracker = param != null; + + this.localHash=param; + + + } + + + /** + * field for URI + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localURI ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localURITracker = false ; + + public boolean isURISpecified(){ + return localURITracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getURI(){ + return localURI; + } + + + + /** + * Auto generated setter method + * @param param URI + */ + public void setURI(org.apache.axis2.databinding.types.URI param){ + + clearAllSettingTrackers(); + localURITracker = param != null; + + this.localURI=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformParameterType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformParameterType", + xmlWriter); + } + + + } + + if (localURI != null){ + + writeAttribute("", + "URI", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localURI is null"); + } + if (localBase64ContentTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Base64Content", xmlWriter); + + + if (localBase64Content!=null) { + try { + org.apache.axiom.util.stax.XMLStreamWriterUtils.writeDataHandler(xmlWriter, localBase64Content, null, true); + } catch (java.io.IOException ex) { + throw new javax.xml.stream.XMLStreamException("Unable to read data handler for Base64Content", ex); + } + } else { + + } + + xmlWriter.writeEndElement(); + } if (localHashTracker){ + if (localHash==null){ + throw new org.apache.axis2.databinding.ADBException("Hash cannot be null!!"); + } + localHash.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Hash"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localBase64ContentTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Base64Content")); + + elementList.add(localBase64Content); + } if (localHashTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Hash")); + + + if (localHash==null){ + throw new org.apache.axis2.databinding.ADBException("Hash cannot be null!!"); + } + elementList.add(localHash); + } + attribList.add( + new javax.xml.namespace.QName("","URI")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localURI)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformParameterType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformParameterType object = + new TransformParameterType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformParameterType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformParameterType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "URI" + java.lang.String tempAttribURI = + + reader.getAttributeValue(null,"URI"); + + if (tempAttribURI!=null){ + java.lang.String content = tempAttribURI; + + object.setURI( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribURI)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute URI is missing"); + + } + handledAttributes.add("URI"); + + + reader.next(); + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Base64Content").equals(reader.getName())){ + + object.setBase64Content(org.apache.axiom.util.stax.XMLStreamReaderUtils.getDataHandlerFromElement(reader)); + + reader.next(); + + } // End of if for expected property start element + + else + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Hash").equals(reader.getName())){ + + object.setHash(Hash_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ManifestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ManifestType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Reference + * This was an Array! + */ + + + protected ReferenceType[] localReference ; + + + /** + * Auto generated getter method + * @return ReferenceType[] + */ + public ReferenceType[] getReference(){ + return localReference; + } + + + + + + + /** + * validate the array for Reference + */ + protected void validateReference(ReferenceType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param Reference + */ + public void setReference(ReferenceType[] param){ + + validateReference(param); + + + this.localReference=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ReferenceType + */ + public void addReference(ReferenceType param){ + if (localReference == null){ + localReference = new ReferenceType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localReference); + list.add(param); + this.localReference = + (ReferenceType[])list.toArray( + new ReferenceType[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ManifestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ManifestType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localReference!=null){ + for (int i = 0;i < localReference.length;i++){ + if (localReference[i] != null){ + localReference[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localReference!=null) { + for (int i = 0;i < localReference.length;i++){ + + if (localReference[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Reference")); + elementList.add(localReference[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Reference cannot be null!!"); + + } + + + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ManifestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ManifestType object = + new ManifestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ManifestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ManifestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(ReferenceType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Reference").equals(reader.getName())){ + list1.add(ReferenceType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setReference((ReferenceType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ReferenceType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Transform + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "Transform", + "ns1"); + + + + /** + * field for Transform + */ + + + protected TransformType localTransform ; + + + /** + * Auto generated getter method + * @return TransformType + */ + public TransformType getTransform(){ + return localTransform; + } + + + + /** + * Auto generated setter method + * @param param Transform + */ + public void setTransform(TransformType param){ + + this.localTransform=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localTransform==null){ + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!"); + } + localTransform.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localTransform.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Transform parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Transform object = + new Transform(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform").equals(reader.getName())){ + + object.setTransform(TransformType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class HMACOutputLengthType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "HMACOutputLengthType", + "ns1"); + + + + /** + * field for HMACOutputLengthType + */ + + + protected java.math.BigInteger localHMACOutputLengthType ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getHMACOutputLengthType(){ + return localHMACOutputLengthType; + } + + + + /** + * Auto generated setter method + * @param param HMACOutputLengthType + */ + public void setHMACOutputLengthType(java.math.BigInteger param){ + + this.localHMACOutputLengthType=param; + + + } + + + public java.lang.String toString(){ + + return localHMACOutputLengthType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":HMACOutputLengthType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "HMACOutputLengthType", + xmlWriter); + } + } + + if (localHMACOutputLengthType==null){ + + throw new org.apache.axis2.databinding.ADBException("HMACOutputLengthType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHMACOutputLengthType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localHMACOutputLengthType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static HMACOutputLengthType fromString(java.lang.String value, + java.lang.String namespaceURI){ + HMACOutputLengthType returnValue = new HMACOutputLengthType(); + + returnValue.setHMACOutputLengthType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(value)); + + + return returnValue; + } + + public static HMACOutputLengthType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return HMACOutputLengthType.Factory.fromString(content,namespaceUri); + } else { + return HMACOutputLengthType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static HMACOutputLengthType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + HMACOutputLengthType object = + new HMACOutputLengthType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"HMACOutputLengthType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setHMACOutputLengthType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateSignatureLocationType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateSignatureLocationType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Token + */ + + + protected org.apache.axis2.databinding.types.Token localToken ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getToken(){ + return localToken; + } + + + + /** + * Auto generated setter method + * @param param Token + */ + public void setToken(org.apache.axis2.databinding.types.Token param){ + + this.localToken=param; + + + } + + + public java.lang.String toString(){ + + return localToken.toString(); + + } + + + /** + * field for Index + * This was an Attribute! + */ + + + protected java.math.BigInteger localIndex ; + + + /** + * Auto generated getter method + * @return java.math.BigInteger + */ + public java.math.BigInteger getIndex(){ + return localIndex; + } + + + + /** + * Auto generated setter method + * @param param Index + */ + public void setIndex(java.math.BigInteger param){ + + this.localIndex=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateSignatureLocationType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateSignatureLocationType", + xmlWriter); + } + + + } + + if (localIndex != null){ + + writeAttribute("", + "Index", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIndex), xmlWriter); + + + } + + else { + throw new org.apache.axis2.databinding.ADBException("required attribute localIndex is null"); + } + + + if (localToken==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("token cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localToken)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + + elementList.add(org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT); + + if (localToken != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localToken)); + } else { + throw new org.apache.axis2.databinding.ADBException("token cannot be null!!"); + } + + attribList.add( + new javax.xml.namespace.QName("","Index")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localIndex)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static CreateSignatureLocationType fromString(java.lang.String value, + java.lang.String namespaceURI){ + CreateSignatureLocationType returnValue = new CreateSignatureLocationType(); + + returnValue.setToken( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + return returnValue; + } + + public static CreateSignatureLocationType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return CreateSignatureLocationType.Factory.fromString(content,namespaceUri); + } else { + return CreateSignatureLocationType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateSignatureLocationType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateSignatureLocationType object = + new CreateSignatureLocationType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateSignatureLocationType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateSignatureLocationType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Index" + java.lang.String tempAttribIndex = + + reader.getAttributeValue(null,"Index"); + + if (tempAttribIndex!=null){ + java.lang.String content = tempAttribIndex; + + object.setIndex( + org.apache.axis2.databinding.utils.ConverterUtil.convertToInteger(tempAttribIndex)); + + } else { + + throw new org.apache.axis2.databinding.ADBException("Required attribute Index is missing"); + + } + handledAttributes.add("Index"); + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"token" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setToken( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class TransformsType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = TransformsType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for Transform + * This was an Array! + */ + + + protected TransformType[] localTransform ; + + + /** + * Auto generated getter method + * @return TransformType[] + */ + public TransformType[] getTransform(){ + return localTransform; + } + + + + + + + /** + * validate the array for Transform + */ + protected void validateTransform(TransformType[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param Transform + */ + public void setTransform(TransformType[] param){ + + validateTransform(param); + + + this.localTransform=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param TransformType + */ + public void addTransform(TransformType param){ + if (localTransform == null){ + localTransform = new TransformType[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localTransform); + list.add(param); + this.localTransform = + (TransformType[])list.toArray( + new TransformType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":TransformsType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "TransformsType", + xmlWriter); + } + + + } + + if (localTransform!=null){ + for (int i = 0;i < localTransform.length;i++){ + if (localTransform[i] != null){ + localTransform[i].serialize(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform"), + xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!!"); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localTransform!=null) { + for (int i = 0;i < localTransform.length;i++){ + + if (localTransform[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "Transform")); + elementList.add(localTransform[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Transform cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static TransformsType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + TransformsType object = + new TransformsType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"TransformsType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (TransformsType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list1.add(TransformType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + if (new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","Transform").equals(reader.getName())){ + list1.add(TransformType.Factory.parse(reader)); + + }else{ + loopDone1 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setTransform((TransformType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + TransformType.class, + list1)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateXMLSignatureResponseType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateXMLSignatureResponseType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateXMLSignatureResponseTypeChoice + * This was an Array! + */ + + + protected CreateXMLSignatureResponseTypeChoice[] localCreateXMLSignatureResponseTypeChoice ; + + + /** + * Auto generated getter method + * @return CreateXMLSignatureResponseTypeChoice[] + */ + public CreateXMLSignatureResponseTypeChoice[] getCreateXMLSignatureResponseTypeChoice(){ + return localCreateXMLSignatureResponseTypeChoice; + } + + + + + + + /** + * validate the array for CreateXMLSignatureResponseTypeChoice + */ + protected void validateCreateXMLSignatureResponseTypeChoice(CreateXMLSignatureResponseTypeChoice[] param){ + + if ((param != null) && (param.length < 1)){ + throw new java.lang.RuntimeException(); + } + + } + + + /** + * Auto generated setter method + * @param param CreateXMLSignatureResponseTypeChoice + */ + public void setCreateXMLSignatureResponseTypeChoice(CreateXMLSignatureResponseTypeChoice[] param){ + + validateCreateXMLSignatureResponseTypeChoice(param); + + + this.localCreateXMLSignatureResponseTypeChoice=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param CreateXMLSignatureResponseTypeChoice + */ + public void addCreateXMLSignatureResponseTypeChoice(CreateXMLSignatureResponseTypeChoice param){ + if (localCreateXMLSignatureResponseTypeChoice == null){ + localCreateXMLSignatureResponseTypeChoice = new CreateXMLSignatureResponseTypeChoice[]{}; + } + + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localCreateXMLSignatureResponseTypeChoice); + list.add(param); + this.localCreateXMLSignatureResponseTypeChoice = + (CreateXMLSignatureResponseTypeChoice[])list.toArray( + new CreateXMLSignatureResponseTypeChoice[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateXMLSignatureResponseType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateXMLSignatureResponseType", + xmlWriter); + } + + + } + + + if (localCreateXMLSignatureResponseTypeChoice!=null){ + for (int i = 0;i < localCreateXMLSignatureResponseTypeChoice.length;i++){ + if (localCreateXMLSignatureResponseTypeChoice[i] != null){ + localCreateXMLSignatureResponseTypeChoice[i].serialize(null,xmlWriter); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null!!"); + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null!!"); + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + if (localCreateXMLSignatureResponseTypeChoice!=null) { + for (int i = 0;i < localCreateXMLSignatureResponseTypeChoice.length;i++){ + + if (localCreateXMLSignatureResponseTypeChoice[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateXMLSignatureResponseTypeChoice")); + elementList.add(localCreateXMLSignatureResponseTypeChoice[i]); + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null !!"); + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("CreateXMLSignatureResponseTypeChoice cannot be null!!"); + + } + + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateXMLSignatureResponseType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateXMLSignatureResponseType object = + new CreateXMLSignatureResponseType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateXMLSignatureResponseType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateXMLSignatureResponseType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(CreateXMLSignatureResponseTypeChoice.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(CreateXMLSignatureResponseTypeChoice.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setCreateXMLSignatureResponseTypeChoice((CreateXMLSignatureResponseTypeChoice[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + CreateXMLSignatureResponseTypeChoice.class, + list1)); + + + } // End of if for expected property start element + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CreateTransformsInfoProfile_type0 + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CreateTransformsInfoProfile_type0 + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for CreateTransformsInfo + */ + + + protected TransformsInfoType localCreateTransformsInfo ; + + + /** + * Auto generated getter method + * @return TransformsInfoType + */ + public TransformsInfoType getCreateTransformsInfo(){ + return localCreateTransformsInfo; + } + + + + /** + * Auto generated setter method + * @param param CreateTransformsInfo + */ + public void setCreateTransformsInfo(TransformsInfoType param){ + + this.localCreateTransformsInfo=param; + + + } + + + /** + * field for Supplement + * This was an Array! + */ + + + protected XMLDataObjectAssociationType[] localSupplement ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSupplementTracker = false ; + + public boolean isSupplementSpecified(){ + return localSupplementTracker; + } + + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType[] + */ + public XMLDataObjectAssociationType[] getSupplement(){ + return localSupplement; + } + + + + + + + /** + * validate the array for Supplement + */ + protected void validateSupplement(XMLDataObjectAssociationType[] param){ + + } + + + /** + * Auto generated setter method + * @param param Supplement + */ + public void setSupplement(XMLDataObjectAssociationType[] param){ + + validateSupplement(param); + + localSupplementTracker = param != null; + + this.localSupplement=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param XMLDataObjectAssociationType + */ + public void addSupplement(XMLDataObjectAssociationType param){ + if (localSupplement == null){ + localSupplement = new XMLDataObjectAssociationType[]{}; + } + + + //update the setting tracker + localSupplementTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localSupplement); + list.add(param); + this.localSupplement = + (XMLDataObjectAssociationType[])list.toArray( + new XMLDataObjectAssociationType[list.size()]); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CreateTransformsInfoProfile_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CreateTransformsInfoProfile_type0", + xmlWriter); + } + + + } + + if (localCreateTransformsInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfo cannot be null!!"); + } + localCreateTransformsInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfo"), + xmlWriter); + if (localSupplementTracker){ + if (localSupplement!=null){ + for (int i = 0;i < localSupplement.length;i++){ + if (localSupplement[i] != null){ + localSupplement[i].serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement"), + xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "CreateTransformsInfo")); + + + if (localCreateTransformsInfo==null){ + throw new org.apache.axis2.databinding.ADBException("CreateTransformsInfo cannot be null!!"); + } + elementList.add(localCreateTransformsInfo); + if (localSupplementTracker){ + if (localSupplement!=null) { + for (int i = 0;i < localSupplement.length;i++){ + + if (localSupplement[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Supplement")); + elementList.add(localSupplement[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!!"); + + } + + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CreateTransformsInfoProfile_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CreateTransformsInfoProfile_type0 object = + new CreateTransformsInfoProfile_type0(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CreateTransformsInfoProfile_type0".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CreateTransformsInfoProfile_type0)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list2 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","CreateTransformsInfo").equals(reader.getName())){ + + object.setCreateTransformsInfo(TransformsInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + + + + // Process the array and step past its final element's end. + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + //loop until we find a start element that is not part of this array + boolean loopDone2 = false; + while(!loopDone2){ + // We should be at the end element, but make sure + while (!reader.isEndElement()) + reader.next(); + // Step out of this element + reader.next(); + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone2 = true; + } else { + if (new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + list2.add(XMLDataObjectAssociationType.Factory.parse(reader)); + + }else{ + loopDone2 = true; + } + } + } + // call the converter utility to convert and set the array + + object.setSupplement((XMLDataObjectAssociationType[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + XMLDataObjectAssociationType.class, + list2)); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ErrorResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "ErrorResponse", + "ns2"); + + + + /** + * field for ErrorResponse + */ + + + protected ErrorResponseType localErrorResponse ; + + + /** + * Auto generated getter method + * @return ErrorResponseType + */ + public ErrorResponseType getErrorResponse(){ + return localErrorResponse; + } + + + + /** + * Auto generated setter method + * @param param ErrorResponse + */ + public void setErrorResponse(ErrorResponseType param){ + + this.localErrorResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localErrorResponse==null){ + throw new org.apache.axis2.databinding.ADBException("ErrorResponse cannot be null!"); + } + localErrorResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localErrorResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ErrorResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ErrorResponse object = + new ErrorResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","ErrorResponse").equals(reader.getName())){ + + object.setErrorResponse(ErrorResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Space_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/XML/1998/namespace", + "space_type0", + "ns3"); + + + + /** + * field for Space_type0 + */ + + + protected org.apache.axis2.databinding.types.NCName localSpace_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Space_type0(org.apache.axis2.databinding.types.NCName value, boolean isRegisterValue) { + localSpace_type0 = value; + if (isRegisterValue){ + + _table_.put(localSpace_type0, this); + + } + + } + + public static final org.apache.axis2.databinding.types.NCName _value1 = + org.apache.axis2.databinding.utils.ConverterUtil.convertToNCName("default"); + + public static final org.apache.axis2.databinding.types.NCName _value2 = + org.apache.axis2.databinding.utils.ConverterUtil.convertToNCName("preserve"); + + public static final Space_type0 value1 = + new Space_type0(_value1,true); + + public static final Space_type0 value2 = + new Space_type0(_value2,true); + + + public org.apache.axis2.databinding.types.NCName getValue() { return localSpace_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localSpace_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/XML/1998/namespace"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":space_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "space_type0", + xmlWriter); + } + } + + if (localSpace_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("space_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSpace_type0)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/XML/1998/namespace")){ + return "ns3"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSpace_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Space_type0 fromValue(org.apache.axis2.databinding.types.NCName value) + throws java.lang.IllegalArgumentException { + Space_type0 enumeration = (Space_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Space_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToNCName(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Space_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Space_type0.Factory.fromString(content,namespaceUri); + } else { + return Space_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Space_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Space_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"space_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Space_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Space_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureRequestType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = VerifyXMLSignatureRequestType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for DateTime + */ + + + protected java.util.Calendar localDateTime ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localDateTimeTracker = false ; + + public boolean isDateTimeSpecified(){ + return localDateTimeTracker; + } + + + + /** + * Auto generated getter method + * @return java.util.Calendar + */ + public java.util.Calendar getDateTime(){ + return localDateTime; + } + + + + /** + * Auto generated setter method + * @param param DateTime + */ + public void setDateTime(java.util.Calendar param){ + localDateTimeTracker = param != null; + + this.localDateTime=param; + + + } + + + /** + * field for VerifySignatureInfo + */ + + + protected VerifySignatureInfo_type0 localVerifySignatureInfo ; + + + /** + * Auto generated getter method + * @return VerifySignatureInfo_type0 + */ + public VerifySignatureInfo_type0 getVerifySignatureInfo(){ + return localVerifySignatureInfo; + } + + + + /** + * Auto generated setter method + * @param param VerifySignatureInfo + */ + public void setVerifySignatureInfo(VerifySignatureInfo_type0 param){ + + this.localVerifySignatureInfo=param; + + + } + + + /** + * field for VerifyXMLSignatureRequestTypeChoice_type0 + * This was an Array! + */ + + + protected VerifyXMLSignatureRequestTypeChoice_type0[] localVerifyXMLSignatureRequestTypeChoice_type0 ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localVerifyXMLSignatureRequestTypeChoice_type0Tracker = false ; + + public boolean isVerifyXMLSignatureRequestTypeChoice_type0Specified(){ + return localVerifyXMLSignatureRequestTypeChoice_type0Tracker; + } + + + + /** + * Auto generated getter method + * @return VerifyXMLSignatureRequestTypeChoice_type0[] + */ + public VerifyXMLSignatureRequestTypeChoice_type0[] getVerifyXMLSignatureRequestTypeChoice_type0(){ + return localVerifyXMLSignatureRequestTypeChoice_type0; + } + + + + + + + /** + * validate the array for VerifyXMLSignatureRequestTypeChoice_type0 + */ + protected void validateVerifyXMLSignatureRequestTypeChoice_type0(VerifyXMLSignatureRequestTypeChoice_type0[] param){ + + } + + + /** + * Auto generated setter method + * @param param VerifyXMLSignatureRequestTypeChoice_type0 + */ + public void setVerifyXMLSignatureRequestTypeChoice_type0(VerifyXMLSignatureRequestTypeChoice_type0[] param){ + + validateVerifyXMLSignatureRequestTypeChoice_type0(param); + + localVerifyXMLSignatureRequestTypeChoice_type0Tracker = param != null; + + this.localVerifyXMLSignatureRequestTypeChoice_type0=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param VerifyXMLSignatureRequestTypeChoice_type0 + */ + public void addVerifyXMLSignatureRequestTypeChoice_type0(VerifyXMLSignatureRequestTypeChoice_type0 param){ + if (localVerifyXMLSignatureRequestTypeChoice_type0 == null){ + localVerifyXMLSignatureRequestTypeChoice_type0 = new VerifyXMLSignatureRequestTypeChoice_type0[]{}; + } + + + //update the setting tracker + localVerifyXMLSignatureRequestTypeChoice_type0Tracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localVerifyXMLSignatureRequestTypeChoice_type0); + list.add(param); + this.localVerifyXMLSignatureRequestTypeChoice_type0 = + (VerifyXMLSignatureRequestTypeChoice_type0[])list.toArray( + new VerifyXMLSignatureRequestTypeChoice_type0[list.size()]); + + } + + + /** + * field for SignatureManifestCheckParams + */ + + + protected SignatureManifestCheckParams_type0 localSignatureManifestCheckParams ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localSignatureManifestCheckParamsTracker = false ; + + public boolean isSignatureManifestCheckParamsSpecified(){ + return localSignatureManifestCheckParamsTracker; + } + + + + /** + * Auto generated getter method + * @return SignatureManifestCheckParams_type0 + */ + public SignatureManifestCheckParams_type0 getSignatureManifestCheckParams(){ + return localSignatureManifestCheckParams; + } + + + + /** + * Auto generated setter method + * @param param SignatureManifestCheckParams + */ + public void setSignatureManifestCheckParams(SignatureManifestCheckParams_type0 param){ + localSignatureManifestCheckParamsTracker = param != null; + + this.localSignatureManifestCheckParams=param; + + + } + + + /** + * field for ReturnHashInputData + */ + + + protected org.apache.axiom.om.OMElement localReturnHashInputData ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localReturnHashInputDataTracker = false ; + + public boolean isReturnHashInputDataSpecified(){ + return localReturnHashInputDataTracker; + } + + + + /** + * Auto generated getter method + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getReturnHashInputData(){ + return localReturnHashInputData; + } + + + + /** + * Auto generated setter method + * @param param ReturnHashInputData + */ + public void setReturnHashInputData(org.apache.axiom.om.OMElement param){ + localReturnHashInputDataTracker = param != null; + + this.localReturnHashInputData=param; + + + } + + + /** + * field for TrustProfileID + */ + + + protected org.apache.axis2.databinding.types.Token localTrustProfileID ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getTrustProfileID(){ + return localTrustProfileID; + } + + + + /** + * Auto generated setter method + * @param param TrustProfileID + */ + public void setTrustProfileID(org.apache.axis2.databinding.types.Token param){ + + this.localTrustProfileID=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":VerifyXMLSignatureRequestType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "VerifyXMLSignatureRequestType", + xmlWriter); + } + + + } + if (localDateTimeTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "DateTime", xmlWriter); + + + if (localDateTime==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + + } + + xmlWriter.writeEndElement(); + } + if (localVerifySignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureInfo cannot be null!!"); + } + localVerifySignatureInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureInfo"), + xmlWriter); + if (localVerifyXMLSignatureRequestTypeChoice_type0Tracker){ + + if (localVerifyXMLSignatureRequestTypeChoice_type0!=null){ + for (int i = 0;i < localVerifyXMLSignatureRequestTypeChoice_type0.length;i++){ + if (localVerifyXMLSignatureRequestTypeChoice_type0[i] != null){ + localVerifyXMLSignatureRequestTypeChoice_type0[i].serialize(null,xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureRequestTypeChoice_type0 cannot be null!!"); + } + } if (localSignatureManifestCheckParamsTracker){ + if (localSignatureManifestCheckParams==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheckParams cannot be null!!"); + } + localSignatureManifestCheckParams.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheckParams"), + xmlWriter); + } if (localReturnHashInputDataTracker){ + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "ReturnHashInputData", xmlWriter); + + + if (localReturnHashInputData==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("ReturnHashInputData cannot be null!!"); + + }else{ + + localReturnHashInputData.serialize(xmlWriter); + + } + + xmlWriter.writeEndElement(); + } + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "TrustProfileID", xmlWriter); + + + if (localTrustProfileID==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + + } + + xmlWriter.writeEndElement(); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localDateTimeTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "DateTime")); + + if (localDateTime != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localDateTime)); + } else { + throw new org.apache.axis2.databinding.ADBException("DateTime cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifySignatureInfo")); + + + if (localVerifySignatureInfo==null){ + throw new org.apache.axis2.databinding.ADBException("VerifySignatureInfo cannot be null!!"); + } + elementList.add(localVerifySignatureInfo); + if (localVerifyXMLSignatureRequestTypeChoice_type0Tracker){ + if (localVerifyXMLSignatureRequestTypeChoice_type0!=null) { + for (int i = 0;i < localVerifyXMLSignatureRequestTypeChoice_type0.length;i++){ + + if (localVerifyXMLSignatureRequestTypeChoice_type0[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyXMLSignatureRequestTypeChoice_type0")); + elementList.add(localVerifyXMLSignatureRequestTypeChoice_type0[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureRequestTypeChoice_type0 cannot be null!!"); + + } + + } if (localSignatureManifestCheckParamsTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "SignatureManifestCheckParams")); + + + if (localSignatureManifestCheckParams==null){ + throw new org.apache.axis2.databinding.ADBException("SignatureManifestCheckParams cannot be null!!"); + } + elementList.add(localSignatureManifestCheckParams); + } if (localReturnHashInputDataTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "ReturnHashInputData")); + + if (localReturnHashInputData != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localReturnHashInputData)); + } else { + throw new org.apache.axis2.databinding.ADBException("ReturnHashInputData cannot be null!!"); + } + } + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "TrustProfileID")); + + if (localTrustProfileID != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localTrustProfileID)); + } else { + throw new org.apache.axis2.databinding.ADBException("TrustProfileID cannot be null!!"); + } + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureRequestType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureRequestType object = + new VerifyXMLSignatureRequestType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"VerifyXMLSignatureRequestType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (VerifyXMLSignatureRequestType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + java.util.ArrayList list3 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","DateTime").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"DateTime" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setDateTime( + org.apache.axis2.databinding.utils.ConverterUtil.convertToDateTime(content)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifySignatureInfo").equals(reader.getName())){ + + object.setVerifySignatureInfo(VerifySignatureInfo_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list3.add(VerifyXMLSignatureRequestTypeChoice_type0.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone3 = false; + while(!loopDone3){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone3 = true; + } else { + list3.add(VerifyXMLSignatureRequestTypeChoice_type0.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setVerifyXMLSignatureRequestTypeChoice_type0((VerifyXMLSignatureRequestTypeChoice_type0[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + VerifyXMLSignatureRequestTypeChoice_type0.class, + list3)); + + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","SignatureManifestCheckParams").equals(reader.getName())){ + + object.setSignatureManifestCheckParams(SignatureManifestCheckParams_type0.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ReturnHashInputData" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + org.apache.axiom.om.OMFactory fac = org.apache.axiom.om.OMAbstractFactory.getOMFactory(); + org.apache.axiom.om.OMNamespace omNs = fac.createOMNamespace("http://reference.e-government.gv.at/namespace/moa/20020822#", ""); + org.apache.axiom.om.OMElement _valueReturnHashInputData = fac.createOMElement("ReturnHashInputData", omNs); + _valueReturnHashInputData.addChild(fac.createOMText(_valueReturnHashInputData, content)); + object.setReturnHashInputData(_valueReturnHashInputData); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","TrustProfileID").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"TrustProfileID" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setTrustProfileID( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class DigestValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "DigestValue", + "ns1"); + + + + /** + * field for DigestValue + */ + + + protected DigestValueType localDigestValue ; + + + /** + * Auto generated getter method + * @return DigestValueType + */ + public DigestValueType getDigestValue(){ + return localDigestValue; + } + + + + /** + * Auto generated setter method + * @param param DigestValue + */ + public void setDigestValue(DigestValueType param){ + + this.localDigestValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localDigestValue==null){ + throw new org.apache.axis2.databinding.ADBException("DigestValue cannot be null!"); + } + localDigestValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localDigestValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static DigestValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + DigestValue object = + new DigestValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","DigestValue").equals(reader.getName())){ + + object.setDigestValue(DigestValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ProfileIdentifierType + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "ProfileIdentifierType", + "ns2"); + + + + /** + * field for ProfileIdentifierType + */ + + + protected org.apache.axis2.databinding.types.Token localProfileIdentifierType ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Token + */ + public org.apache.axis2.databinding.types.Token getProfileIdentifierType(){ + return localProfileIdentifierType; + } + + + + /** + * Auto generated setter method + * @param param ProfileIdentifierType + */ + public void setProfileIdentifierType(org.apache.axis2.databinding.types.Token param){ + + this.localProfileIdentifierType=param; + + + } + + + public java.lang.String toString(){ + + return localProfileIdentifierType.toString(); + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ProfileIdentifierType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ProfileIdentifierType", + xmlWriter); + } + } + + if (localProfileIdentifierType==null){ + + throw new org.apache.axis2.databinding.ADBException("ProfileIdentifierType cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localProfileIdentifierType)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localProfileIdentifierType) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static ProfileIdentifierType fromString(java.lang.String value, + java.lang.String namespaceURI){ + ProfileIdentifierType returnValue = new ProfileIdentifierType(); + + returnValue.setProfileIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + return returnValue; + } + + public static ProfileIdentifierType fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return ProfileIdentifierType.Factory.fromString(content,namespaceUri); + } else { + return ProfileIdentifierType.Factory.fromString(content,""); + } + } + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ProfileIdentifierType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ProfileIdentifierType object = + new ProfileIdentifierType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"ProfileIdentifierType" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setProfileIdentifierType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(content)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ManifestRefsCheckResultType extends CheckResultType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ManifestRefsCheckResultType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localCode ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localCode=param; + + + } + + + /** + * field for Info0 + * Type of this field is a subtype of its original. + */ + + + protected ManifestRefsCheckResultInfoType localInfo0 ; + + + /** + * Auto generated getter method + * @return ManifestRefsCheckResultInfoType + */ + public ManifestRefsCheckResultInfoType getInfo0(){ + return localInfo0; + } + + + + /** + * Auto generated setter method + * @param param Info0 + */ + public void setInfo0(ManifestRefsCheckResultInfoType param){ + + this.localInfo0=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ManifestRefsCheckResultType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ManifestRefsCheckResultType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + + } + + xmlWriter.writeEndElement(); + + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + localInfo0.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0"), + xmlWriter); + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info0")); + + + if (localInfo0==null){ + throw new org.apache.axis2.databinding.ADBException("Info0 cannot be null!!"); + } + elementList.add(localInfo0); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ManifestRefsCheckResultType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ManifestRefsCheckResultType object = + new ManifestRefsCheckResultType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ManifestRefsCheckResultType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ManifestRefsCheckResultType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info0").equals(reader.getName())){ + + object.setInfo0(ManifestRefsCheckResultInfoType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class KeyValue + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://www.w3.org/2000/09/xmldsig#", + "KeyValue", + "ns1"); + + + + /** + * field for KeyValue + */ + + + protected KeyValueType localKeyValue ; + + + /** + * Auto generated getter method + * @return KeyValueType + */ + public KeyValueType getKeyValue(){ + return localKeyValue; + } + + + + /** + * Auto generated setter method + * @param param KeyValue + */ + public void setKeyValue(KeyValueType param){ + + this.localKeyValue=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localKeyValue==null){ + throw new org.apache.axis2.databinding.ADBException("KeyValue cannot be null!"); + } + localKeyValue.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localKeyValue.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static KeyValue parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + KeyValue object = + new KeyValue(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#","KeyValue").equals(reader.getName())){ + + object.setKeyValue(KeyValueType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Source_type1 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "source_type1", + "ns2"); + + + + /** + * field for Source_type1 + */ + + + protected org.apache.axis2.databinding.types.Token localSource_type1 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Source_type1(org.apache.axis2.databinding.types.Token value, boolean isRegisterValue) { + localSource_type1 = value; + if (isRegisterValue){ + + _table_.put(localSource_type1, this); + + } + + } + + public static final org.apache.axis2.databinding.types.Token _TSL = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("TSL"); + + public static final org.apache.axis2.databinding.types.Token _Certificate = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("Certificate"); + + public static final Source_type1 TSL = + new Source_type1(_TSL,true); + + public static final Source_type1 Certificate = + new Source_type1(_Certificate,true); + + + public org.apache.axis2.databinding.types.Token getValue() { return localSource_type1;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localSource_type1.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":source_type1", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "source_type1", + xmlWriter); + } + } + + if (localSource_type1==null){ + + throw new org.apache.axis2.databinding.ADBException("source_type1 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type1)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type1) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Source_type1 fromValue(org.apache.axis2.databinding.types.Token value) + throws java.lang.IllegalArgumentException { + Source_type1 enumeration = (Source_type1) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Source_type1 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Source_type1 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Source_type1.Factory.fromString(content,namespaceUri); + } else { + return Source_type1.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Source_type1 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Source_type1 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"source_type1" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Source_type1.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Source_type1.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Source_type0 + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "source_type0", + "ns2"); + + + + /** + * field for Source_type0 + */ + + + protected org.apache.axis2.databinding.types.Token localSource_type0 ; + + private static java.util.HashMap _table_ = new java.util.HashMap(); + + // Constructor + + protected Source_type0(org.apache.axis2.databinding.types.Token value, boolean isRegisterValue) { + localSource_type0 = value; + if (isRegisterValue){ + + _table_.put(localSource_type0, this); + + } + + } + + public static final org.apache.axis2.databinding.types.Token _TSL = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("TSL"); + + public static final org.apache.axis2.databinding.types.Token _Certificate = + org.apache.axis2.databinding.utils.ConverterUtil.convertToToken("Certificate"); + + public static final Source_type0 TSL = + new Source_type0(_TSL,true); + + public static final Source_type0 Certificate = + new Source_type0(_Certificate,true); + + + public org.apache.axis2.databinding.types.Token getValue() { return localSource_type0;} + + public boolean equals(java.lang.Object obj) {return (obj == this);} + public int hashCode() { return toString().hashCode();} + public java.lang.String toString() { + + return localSource_type0.toString(); + + + } + + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + java.lang.String namespace = parentQName.getNamespaceURI(); + java.lang.String _localName = parentQName.getLocalPart(); + + writeStartElement(null, namespace, _localName, xmlWriter); + + // add the type details if this is used in a simple type + if (serializeType){ + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":source_type0", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "source_type0", + xmlWriter); + } + } + + if (localSource_type0==null){ + + throw new org.apache.axis2.databinding.ADBException("source_type0 cannot be null !!"); + + }else{ + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type0)); + + } + + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(MY_QNAME, + new java.lang.Object[]{ + org.apache.axis2.databinding.utils.reader.ADBXMLStreamReader.ELEMENT_TEXT, + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localSource_type0) + }, + null); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + public static Source_type0 fromValue(org.apache.axis2.databinding.types.Token value) + throws java.lang.IllegalArgumentException { + Source_type0 enumeration = (Source_type0) + + _table_.get(value); + + + if ((enumeration == null) && !((value == null) || (value.equals("")))) { + throw new java.lang.IllegalArgumentException(); + } + return enumeration; + } + public static Source_type0 fromString(java.lang.String value,java.lang.String namespaceURI) + throws java.lang.IllegalArgumentException { + try { + + return fromValue(org.apache.axis2.databinding.utils.ConverterUtil.convertToToken(value)); + + + } catch (java.lang.Exception e) { + throw new java.lang.IllegalArgumentException(); + } + } + + public static Source_type0 fromString(javax.xml.stream.XMLStreamReader xmlStreamReader, + java.lang.String content) { + if (content.indexOf(":") > -1){ + java.lang.String prefix = content.substring(0,content.indexOf(":")); + java.lang.String namespaceUri = xmlStreamReader.getNamespaceContext().getNamespaceURI(prefix); + return Source_type0.Factory.fromString(content,namespaceUri); + } else { + return Source_type0.Factory.fromString(content,""); + } + } + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Source_type0 parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Source_type0 object = null; + // initialize a hash map to keep values + java.util.Map attributeMap = new java.util.HashMap(); + java.util.List extraAttributeList = new java.util.ArrayList(); + + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() || reader.hasText()){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"source_type0" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + if (content.indexOf(":") > 0) { + // this seems to be a Qname so find the namespace and send + prefix = content.substring(0, content.indexOf(":")); + namespaceuri = reader.getNamespaceURI(prefix); + object = Source_type0.Factory.fromString(content,namespaceuri); + } else { + // this seems to be not a qname send and empty namespace incase of it is + // check is done in fromString method + object = Source_type0.Factory.fromString(content,""); + } + + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class VerifyXMLSignatureResponse + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "VerifyXMLSignatureResponse", + "ns2"); + + + + /** + * field for VerifyXMLSignatureResponse + */ + + + protected VerifyXMLSignatureResponseType localVerifyXMLSignatureResponse ; + + + /** + * Auto generated getter method + * @return VerifyXMLSignatureResponseType + */ + public VerifyXMLSignatureResponseType getVerifyXMLSignatureResponse(){ + return localVerifyXMLSignatureResponse; + } + + + + /** + * Auto generated setter method + * @param param VerifyXMLSignatureResponse + */ + public void setVerifyXMLSignatureResponse(VerifyXMLSignatureResponseType param){ + + this.localVerifyXMLSignatureResponse=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localVerifyXMLSignatureResponse==null){ + throw new org.apache.axis2.databinding.ADBException("VerifyXMLSignatureResponse cannot be null!"); + } + localVerifyXMLSignatureResponse.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localVerifyXMLSignatureResponse.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static VerifyXMLSignatureResponse parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + VerifyXMLSignatureResponse object = + new VerifyXMLSignatureResponse(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","VerifyXMLSignatureResponse").equals(reader.getName())){ + + object.setVerifyXMLSignatureResponse(VerifyXMLSignatureResponseType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class CheckResultType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = CheckResultType + Namespace URI = http://reference.e-government.gv.at/namespace/moa/20020822# + Namespace Prefix = ns2 + */ + + + /** + * field for Code + */ + + + protected org.apache.axis2.databinding.types.NonNegativeInteger localCode ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.NonNegativeInteger + */ + public org.apache.axis2.databinding.types.NonNegativeInteger getCode(){ + return localCode; + } + + + + /** + * Auto generated setter method + * @param param Code + */ + public void setCode(org.apache.axis2.databinding.types.NonNegativeInteger param){ + + this.localCode=param; + + + } + + + /** + * field for Info + */ + + + protected AnyChildrenType localInfo ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localInfoTracker = false ; + + public boolean isInfoSpecified(){ + return localInfoTracker; + } + + + + /** + * Auto generated getter method + * @return AnyChildrenType + */ + public AnyChildrenType getInfo(){ + return localInfo; + } + + + + /** + * Auto generated setter method + * @param param Info + */ + public void setInfo(AnyChildrenType param){ + localInfoTracker = param != null; + + this.localInfo=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://reference.e-government.gv.at/namespace/moa/20020822#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":CheckResultType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "CheckResultType", + xmlWriter); + } + + + } + + namespace = "http://reference.e-government.gv.at/namespace/moa/20020822#"; + writeStartElement(null, namespace, "Code", xmlWriter); + + + if (localCode==null){ + // write the nil attribute + + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + + }else{ + + + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + + } + + xmlWriter.writeEndElement(); + if (localInfoTracker){ + if (localInfo==null){ + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + } + localInfo.serialize(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info"), + xmlWriter); + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Code")); + + if (localCode != null){ + elementList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localCode)); + } else { + throw new org.apache.axis2.databinding.ADBException("Code cannot be null!!"); + } + if (localInfoTracker){ + elementList.add(new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#", + "Info")); + + + if (localInfo==null){ + throw new org.apache.axis2.databinding.ADBException("Info cannot be null!!"); + } + elementList.add(localInfo); + } + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static CheckResultType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + CheckResultType object = + new CheckResultType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"CheckResultType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (CheckResultType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + + reader.next(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Code").equals(reader.getName())){ + + nillableValue = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","nil"); + if ("true".equals(nillableValue) || "1".equals(nillableValue)){ + throw new org.apache.axis2.databinding.ADBException("The element: "+"Code" +" cannot be null"); + } + + + java.lang.String content = reader.getElementText(); + + object.setCode( + org.apache.axis2.databinding.utils.ConverterUtil.convertToNonNegativeInteger(content)); + + reader.next(); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Info").equals(reader.getName())){ + + object.setInfo(AnyChildrenType.Factory.parse(reader)); + + reader.next(); + + } // End of if for expected property start element + + else { + + } + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class ObjectType + implements org.apache.axis2.databinding.ADBBean{ + /* This type was generated from the piece of schema that had + name = ObjectType + Namespace URI = http://www.w3.org/2000/09/xmldsig# + Namespace Prefix = ns1 + */ + + + /** + * field for ObjectTypeSequence + * This was an Array! + */ + + + protected ObjectTypeSequence[] localObjectTypeSequence ; + + /* This tracker boolean wil be used to detect whether the user called the set method + * for this attribute. It will be used to determine whether to include this field + * in the serialized XML + */ + protected boolean localObjectTypeSequenceTracker = false ; + + public boolean isObjectTypeSequenceSpecified(){ + return localObjectTypeSequenceTracker; + } + + + + /** + * Auto generated getter method + * @return ObjectTypeSequence[] + */ + public ObjectTypeSequence[] getObjectTypeSequence(){ + return localObjectTypeSequence; + } + + + + + + + /** + * validate the array for ObjectTypeSequence + */ + protected void validateObjectTypeSequence(ObjectTypeSequence[] param){ + + } + + + /** + * Auto generated setter method + * @param param ObjectTypeSequence + */ + public void setObjectTypeSequence(ObjectTypeSequence[] param){ + + validateObjectTypeSequence(param); + + localObjectTypeSequenceTracker = param != null; + + this.localObjectTypeSequence=param; + } + + + + /** + * Auto generated add method for the array for convenience + * @param param ObjectTypeSequence + */ + public void addObjectTypeSequence(ObjectTypeSequence param){ + if (localObjectTypeSequence == null){ + localObjectTypeSequence = new ObjectTypeSequence[]{}; + } + + + //update the setting tracker + localObjectTypeSequenceTracker = true; + + + java.util.List list = + org.apache.axis2.databinding.utils.ConverterUtil.toList(localObjectTypeSequence); + list.add(param); + this.localObjectTypeSequence = + (ObjectTypeSequence[])list.toArray( + new ObjectTypeSequence[list.size()]); + + } + + + /** + * field for Id + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.Id localId ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.Id + */ + public org.apache.axis2.databinding.types.Id getId(){ + return localId; + } + + + + /** + * Auto generated setter method + * @param param Id + */ + public void setId(org.apache.axis2.databinding.types.Id param){ + + this.localId=param; + + + } + + + /** + * field for MimeType + * This was an Attribute! + */ + + + protected java.lang.String localMimeType ; + + + /** + * Auto generated getter method + * @return java.lang.String + */ + public java.lang.String getMimeType(){ + return localMimeType; + } + + + + /** + * Auto generated setter method + * @param param MimeType + */ + public void setMimeType(java.lang.String param){ + + this.localMimeType=param; + + + } + + + /** + * field for Encoding + * This was an Attribute! + */ + + + protected org.apache.axis2.databinding.types.URI localEncoding ; + + + /** + * Auto generated getter method + * @return org.apache.axis2.databinding.types.URI + */ + public org.apache.axis2.databinding.types.URI getEncoding(){ + return localEncoding; + } + + + + /** + * Auto generated setter method + * @param param Encoding + */ + public void setEncoding(org.apache.axis2.databinding.types.URI param){ + + this.localEncoding=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,parentQName); + return factory.createOMElement(dataSource,parentQName); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + + + java.lang.String prefix = null; + java.lang.String namespace = null; + + + prefix = parentQName.getPrefix(); + namespace = parentQName.getNamespaceURI(); + writeStartElement(prefix, namespace, parentQName.getLocalPart(), xmlWriter); + + if (serializeType){ + + + java.lang.String namespacePrefix = registerPrefix(xmlWriter,"http://www.w3.org/2000/09/xmldsig#"); + if ((namespacePrefix != null) && (namespacePrefix.trim().length() > 0)){ + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + namespacePrefix+":ObjectType", + xmlWriter); + } else { + writeAttribute("xsi","http://www.w3.org/2001/XMLSchema-instance","type", + "ObjectType", + xmlWriter); + } + + + } + + if (localId != null){ + + writeAttribute("", + "Id", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId), xmlWriter); + + + } + + if (localMimeType != null){ + + writeAttribute("", + "MimeType", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeType), xmlWriter); + + + } + + if (localEncoding != null){ + + writeAttribute("", + "Encoding", + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEncoding), xmlWriter); + + + } + if (localObjectTypeSequenceTracker){ + + if (localObjectTypeSequence!=null){ + for (int i = 0;i < localObjectTypeSequence.length;i++){ + if (localObjectTypeSequence[i] != null){ + localObjectTypeSequence[i].serialize(null,xmlWriter); + } else { + + // we don't have to do any thing since minOccures is zero + + } + + } + } else { + throw new org.apache.axis2.databinding.ADBException("ObjectTypeSequence cannot be null!!"); + } + } + xmlWriter.writeEndElement(); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://www.w3.org/2000/09/xmldsig#")){ + return "ns1"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + java.util.ArrayList elementList = new java.util.ArrayList(); + java.util.ArrayList attribList = new java.util.ArrayList(); + + if (localObjectTypeSequenceTracker){ + if (localObjectTypeSequence!=null) { + for (int i = 0;i < localObjectTypeSequence.length;i++){ + + if (localObjectTypeSequence[i] != null){ + elementList.add(new javax.xml.namespace.QName("http://www.w3.org/2000/09/xmldsig#", + "ObjectTypeSequence")); + elementList.add(localObjectTypeSequence[i]); + } else { + + // nothing to do + + } + + } + } else { + + throw new org.apache.axis2.databinding.ADBException("ObjectTypeSequence cannot be null!!"); + + } + + } + attribList.add( + new javax.xml.namespace.QName("","Id")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localId)); + + attribList.add( + new javax.xml.namespace.QName("","MimeType")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localMimeType)); + + attribList.add( + new javax.xml.namespace.QName("","Encoding")); + + attribList.add(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(localEncoding)); + + + return new org.apache.axis2.databinding.utils.reader.ADBXMLStreamReaderImpl(qName, elementList.toArray(), attribList.toArray()); + + + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static ObjectType parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + ObjectType object = + new ObjectType(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + if (reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance","type")!=null){ + java.lang.String fullTypeName = reader.getAttributeValue("http://www.w3.org/2001/XMLSchema-instance", + "type"); + if (fullTypeName!=null){ + java.lang.String nsPrefix = null; + if (fullTypeName.indexOf(":") > -1){ + nsPrefix = fullTypeName.substring(0,fullTypeName.indexOf(":")); + } + nsPrefix = nsPrefix==null?"":nsPrefix; + + java.lang.String type = fullTypeName.substring(fullTypeName.indexOf(":")+1); + + if (!"ObjectType".equals(type)){ + //find namespace for the prefix + java.lang.String nsUri = reader.getNamespaceContext().getNamespaceURI(nsPrefix); + return (ObjectType)ExtensionMapper.getTypeObject( + nsUri,type,reader); + } + + + } + + + } + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + // handle attribute "Id" + java.lang.String tempAttribId = + + reader.getAttributeValue(null,"Id"); + + if (tempAttribId!=null){ + java.lang.String content = tempAttribId; + + object.setId( + org.apache.axis2.databinding.utils.ConverterUtil.convertToID(tempAttribId)); + + } else { + + } + handledAttributes.add("Id"); + + // handle attribute "MimeType" + java.lang.String tempAttribMimeType = + + reader.getAttributeValue(null,"MimeType"); + + if (tempAttribMimeType!=null){ + java.lang.String content = tempAttribMimeType; + + object.setMimeType( + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(tempAttribMimeType)); + + } else { + + } + handledAttributes.add("MimeType"); + + // handle attribute "Encoding" + java.lang.String tempAttribEncoding = + + reader.getAttributeValue(null,"Encoding"); + + if (tempAttribEncoding!=null){ + java.lang.String content = tempAttribEncoding; + + object.setEncoding( + org.apache.axis2.databinding.utils.ConverterUtil.convertToAnyURI(tempAttribEncoding)); + + } else { + + } + handledAttributes.add("Encoding"); + + + reader.next(); + + java.util.ArrayList list1 = new java.util.ArrayList(); + + + while (!reader.isStartElement() && !reader.isEndElement()) reader.next(); + + + try{ + + if (reader.isStartElement() ){ + + + + // Process the array and step past its final element's end. + list1.add(ObjectTypeSequence.Factory.parse(reader)); + //loop until we find a start element that is not part of this array + boolean loopDone1 = false; + while(!loopDone1){ + + // Step to next element event. + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + if (reader.isEndElement()){ + //two continuous end elements means we are exiting the xml structure + loopDone1 = true; + } else { + list1.add(ObjectTypeSequence.Factory.parse(reader)); + } + } + // call the converter utility to convert and set the array + object.setObjectTypeSequence((ObjectTypeSequence[]) + org.apache.axis2.databinding.utils.ConverterUtil.convertToArray( + ObjectTypeSequence.class, + list1)); + + + } // End of if for expected property start element + + else { + + } + + + } catch (java.lang.Exception e) {} + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + if (reader.isStartElement()) + // A start element we are not expecting indicates a trailing invalid property + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + public static class Supplement + implements org.apache.axis2.databinding.ADBBean{ + + public static final javax.xml.namespace.QName MY_QNAME = new javax.xml.namespace.QName( + "http://reference.e-government.gv.at/namespace/moa/20020822#", + "Supplement", + "ns2"); + + + + /** + * field for Supplement + */ + + + protected XMLDataObjectAssociationType localSupplement ; + + + /** + * Auto generated getter method + * @return XMLDataObjectAssociationType + */ + public XMLDataObjectAssociationType getSupplement(){ + return localSupplement; + } + + + + /** + * Auto generated setter method + * @param param Supplement + */ + public void setSupplement(XMLDataObjectAssociationType param){ + + this.localSupplement=param; + + + } + + + + + /** + * + * @param parentQName + * @param factory + * @return org.apache.axiom.om.OMElement + */ + public org.apache.axiom.om.OMElement getOMElement ( + final javax.xml.namespace.QName parentQName, + final org.apache.axiom.om.OMFactory factory) throws org.apache.axis2.databinding.ADBException{ + + + + org.apache.axiom.om.OMDataSource dataSource = + new org.apache.axis2.databinding.ADBDataSource(this,MY_QNAME); + return factory.createOMElement(dataSource,MY_QNAME); + + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + serialize(parentQName,xmlWriter,false); + } + + public void serialize(final javax.xml.namespace.QName parentQName, + javax.xml.stream.XMLStreamWriter xmlWriter, + boolean serializeType) + throws javax.xml.stream.XMLStreamException, org.apache.axis2.databinding.ADBException{ + + + //We can safely assume an element has only one type associated with it + + if (localSupplement==null){ + throw new org.apache.axis2.databinding.ADBException("Supplement cannot be null!"); + } + localSupplement.serialize(MY_QNAME,xmlWriter); + + + } + + private static java.lang.String generatePrefix(java.lang.String namespace) { + if(namespace.equals("http://reference.e-government.gv.at/namespace/moa/20020822#")){ + return "ns2"; + } + return org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + + /** + * Utility method to write an element start tag. + */ + private void writeStartElement(java.lang.String prefix, java.lang.String namespace, java.lang.String localPart, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String writerPrefix = xmlWriter.getPrefix(namespace); + if (writerPrefix != null) { + xmlWriter.writeStartElement(namespace, localPart); + } else { + if (namespace.length() == 0) { + prefix = ""; + } else if (prefix == null) { + prefix = generatePrefix(namespace); + } + + xmlWriter.writeStartElement(prefix, localPart, namespace); + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + } + + /** + * Util method to write an attribute with the ns prefix + */ + private void writeAttribute(java.lang.String prefix,java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (xmlWriter.getPrefix(namespace) == null) { + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + xmlWriter.writeAttribute(namespace,attName,attValue); + } + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeAttribute(java.lang.String namespace,java.lang.String attName, + java.lang.String attValue,javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException{ + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName,attValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace,attName,attValue); + } + } + + + /** + * Util method to write an attribute without the ns prefix + */ + private void writeQNameAttribute(java.lang.String namespace, java.lang.String attName, + javax.xml.namespace.QName qname, javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + java.lang.String attributeNamespace = qname.getNamespaceURI(); + java.lang.String attributePrefix = xmlWriter.getPrefix(attributeNamespace); + if (attributePrefix == null) { + attributePrefix = registerPrefix(xmlWriter, attributeNamespace); + } + java.lang.String attributeValue; + if (attributePrefix.trim().length() > 0) { + attributeValue = attributePrefix + ":" + qname.getLocalPart(); + } else { + attributeValue = qname.getLocalPart(); + } + + if (namespace.equals("")) { + xmlWriter.writeAttribute(attName, attributeValue); + } else { + registerPrefix(xmlWriter, namespace); + xmlWriter.writeAttribute(namespace, attName, attributeValue); + } + } + /** + * method to handle Qnames + */ + + private void writeQName(javax.xml.namespace.QName qname, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + java.lang.String namespaceURI = qname.getNamespaceURI(); + if (namespaceURI != null) { + java.lang.String prefix = xmlWriter.getPrefix(namespaceURI); + if (prefix == null) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + xmlWriter.writeCharacters(prefix + ":" + org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } else { + // i.e this is the default namespace + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + + } else { + xmlWriter.writeCharacters(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qname)); + } + } + + private void writeQNames(javax.xml.namespace.QName[] qnames, + javax.xml.stream.XMLStreamWriter xmlWriter) throws javax.xml.stream.XMLStreamException { + + if (qnames != null) { + // we have to store this data until last moment since it is not possible to write any + // namespace data after writing the charactor data + java.lang.StringBuffer stringToWrite = new java.lang.StringBuffer(); + java.lang.String namespaceURI = null; + java.lang.String prefix = null; + + for (int i = 0; i < qnames.length; i++) { + if (i > 0) { + stringToWrite.append(" "); + } + namespaceURI = qnames[i].getNamespaceURI(); + if (namespaceURI != null) { + prefix = xmlWriter.getPrefix(namespaceURI); + if ((prefix == null) || (prefix.length() == 0)) { + prefix = generatePrefix(namespaceURI); + xmlWriter.writeNamespace(prefix, namespaceURI); + xmlWriter.setPrefix(prefix,namespaceURI); + } + + if (prefix.trim().length() > 0){ + stringToWrite.append(prefix).append(":").append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } else { + stringToWrite.append(org.apache.axis2.databinding.utils.ConverterUtil.convertToString(qnames[i])); + } + } + xmlWriter.writeCharacters(stringToWrite.toString()); + } + + } + + + /** + * Register a namespace prefix + */ + private java.lang.String registerPrefix(javax.xml.stream.XMLStreamWriter xmlWriter, java.lang.String namespace) throws javax.xml.stream.XMLStreamException { + java.lang.String prefix = xmlWriter.getPrefix(namespace); + if (prefix == null) { + prefix = generatePrefix(namespace); + javax.xml.namespace.NamespaceContext nsContext = xmlWriter.getNamespaceContext(); + while (true) { + java.lang.String uri = nsContext.getNamespaceURI(prefix); + if (uri == null || uri.length() == 0) { + break; + } + prefix = org.apache.axis2.databinding.utils.BeanUtil.getUniquePrefix(); + } + xmlWriter.writeNamespace(prefix, namespace); + xmlWriter.setPrefix(prefix, namespace); + } + return prefix; + } + + + + /** + * databinding method to get an XML representation of this object + * + */ + public javax.xml.stream.XMLStreamReader getPullParser(javax.xml.namespace.QName qName) + throws org.apache.axis2.databinding.ADBException{ + + + + + //We can safely assume an element has only one type associated with it + return localSupplement.getPullParser(MY_QNAME); + + } + + + + /** + * Factory class that keeps the parse method + */ + public static class Factory{ + + + + + /** + * static method to create the object + * Precondition: If this object is an element, the current or next start element starts this object and any intervening reader events are ignorable + * If this object is not an element, it is a complex type and the reader is at the event just after the outer start element + * Postcondition: If this object is an element, the reader is positioned at its end element + * If this object is a complex type, the reader is positioned at the end element of its outer element + */ + public static Supplement parse(javax.xml.stream.XMLStreamReader reader) throws java.lang.Exception{ + Supplement object = + new Supplement(); + + int event; + java.lang.String nillableValue = null; + java.lang.String prefix =""; + java.lang.String namespaceuri =""; + try { + + while (!reader.isStartElement() && !reader.isEndElement()) + reader.next(); + + + + + // Note all attributes that were handled. Used to differ normal attributes + // from anyAttributes. + java.util.Vector handledAttributes = new java.util.Vector(); + + + + while(!reader.isEndElement()) { + if (reader.isStartElement() ){ + + if (reader.isStartElement() && new javax.xml.namespace.QName("http://reference.e-government.gv.at/namespace/moa/20020822#","Supplement").equals(reader.getName())){ + + object.setSupplement(XMLDataObjectAssociationType.Factory.parse(reader)); + + } // End of if for expected property start element + + else{ + // A start element we are not expecting indicates an invalid parameter was passed + throw new org.apache.axis2.databinding.ADBException("Unexpected subelement " + reader.getName()); + } + + } else { + reader.next(); + } + } // end of while loop + + + + + } catch (javax.xml.stream.XMLStreamException e) { + throw new java.lang.Exception(e); + } + + return object; + } + + }//end of factory class + + + + } + + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureVerificationServiceStub.ErrorResponse param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureVerificationServiceStub.ErrorResponse.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + private org.apache.axiom.om.OMElement toOM(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse param, boolean optimizeContent) + throws org.apache.axis2.AxisFault { + + + try{ + return param.getOMElement(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse.MY_QNAME, + org.apache.axiom.om.OMAbstractFactory.getOMFactory()); + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + + private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest param, boolean optimizeContent, javax.xml.namespace.QName methodQName) + throws org.apache.axis2.AxisFault{ + + + try{ + + org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope(); + emptyEnvelope.getBody().addChild(param.getOMElement(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest.MY_QNAME,factory)); + return emptyEnvelope; + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + + /* methods to provide back word compatibility */ + + + + private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory, at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest param, boolean optimizeContent, javax.xml.namespace.QName methodQName) + throws org.apache.axis2.AxisFault{ + + + try{ + + org.apache.axiom.soap.SOAPEnvelope emptyEnvelope = factory.getDefaultEnvelope(); + emptyEnvelope.getBody().addChild(param.getOMElement(at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest.MY_QNAME,factory)); + return emptyEnvelope; + } catch(org.apache.axis2.databinding.ADBException e){ + throw org.apache.axis2.AxisFault.makeFault(e); + } + + + } + + + /* methods to provide back word compatibility */ + + + + + /** + * get the default envelope + */ + private org.apache.axiom.soap.SOAPEnvelope toEnvelope(org.apache.axiom.soap.SOAPFactory factory){ + return factory.getDefaultEnvelope(); + } + + + private java.lang.Object fromOM( + org.apache.axiom.om.OMElement param, + java.lang.Class type, + java.util.Map extraNamespaces) throws org.apache.axis2.AxisFault{ + + try { + + if (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest.class.equals(type)){ + + return at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyXMLSignatureResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureVerificationServiceStub.ErrorResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureVerificationServiceStub.ErrorResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest.class.equals(type)){ + + return at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureRequest.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureVerificationServiceStub.VerifyCMSSignatureResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + if (at.gv.egiz.moa.SignatureVerificationServiceStub.ErrorResponse.class.equals(type)){ + + return at.gv.egiz.moa.SignatureVerificationServiceStub.ErrorResponse.Factory.parse(param.getXMLStreamReaderWithoutCaching()); + + + } + + } catch (java.lang.Exception e) { + throw org.apache.axis2.AxisFault.makeFault(e); + } + return null; + } + + + + + } + \ No newline at end of file diff --git a/pdf-as-lib/src/main/java/at/gv/egiz/moa/package-info.java b/pdf-as-lib/src/main/java/at/gv/egiz/moa/package-info.java new file mode 100644 index 00000000..a8a43d6a --- /dev/null +++ b/pdf-as-lib/src/main/java/at/gv/egiz/moa/package-info.java @@ -0,0 +1,8 @@ +/** + * + */ +/** + * @author afitzek + * + */ +package at.gv.egiz.moa; \ No newline at end of file -- cgit v1.2.3