public EndpointReference() 
{

}

No-Arg Constructor Required for Externalizable objects

 public EndpointReference(String address) 
{
        this.address = address;
}

Parameters:

address -

 public static  void addAnonymousEquivalentURI(String anonymousEquivalentURI) 
{
        if (log.isTraceEnabled())
        	log.trace("addAnonymousEquivalentURI: " + anonymousEquivalentURI);
        // Avoid synchronization in hasAnonymousAddress by using the
        // technique outlined at http://is.gd/gv3
        synchronized (anonymousEquivalentURIs) {
        	ArrayList< String > newList = new ArrayList< String >(anonymousEquivalentURIs);
        	newList.add(anonymousEquivalentURI);
            anonymousEquivalentURIs = newList;
        }
}

Adds a parameter to the list of anonymous equivalent URIs.

 public  void addAttribute(OMAttribute omAttribute) 
{
        if (attributes == null) {
            attributes = new ArrayList< OMAttribute >();
        }
        attributes.add(omAttribute);
}

 public  void addAttribute(String localName,
    OMNamespace ns,
    String value) 
{
        if (attributes == null) {
            attributes = new ArrayList< OMAttribute >();
        }
        attributes.add(OMAbstractFactory.getOMFactory().createOMAttribute(localName, ns, value));
}

 public  void addExtensibleElement(OMElement extensibleElement) 
{
        if (extensibleElement != null) {
            if (this.extensibleElements == null) {
                this.extensibleElements = new ArrayList< OMElement >();
            }
            this.extensibleElements.add(extensibleElement);
        }
}

 public  void addMetaData(OMNode metaData) 
{
        if (metaData != null) {
            if (this.metaData == null) {
                this.metaData = new ArrayList< OMNode >();
            }
            this.metaData.add(metaData);
        }
}

 public  void addReferenceParameter(OMElement omElement) 
{
        if (omElement == null) {
            return;
        }
        if (referenceParameters == null) {
            referenceParameters = new HashMap< QName, OMElement >();
        }
        referenceParameters.put(omElement.getQName(), omElement);
}

 public  void addReferenceParameter(QName qname,
    String value) 
{
        if (qname == null) {
            return;
        }
        OMElement omElement = OMAbstractFactory.getOMFactory().createOMElement(qname, null);
        omElement.setText(value);
        addReferenceParameter(omElement);
}

 public  void fromOM(OMElement eprOMElement) 
{
        OMElement addressElement = eprOMElement.getFirstChildWithName(new QName("Address"));
        setAddress(addressElement.getText());
        Iterator allAddrAttributes = addressElement.getAllAttributes();
        if (addressAttributes == null) {
            addressAttributes = new ArrayList< OMAttribute >();
        }
        while (allAddrAttributes.hasNext()) {
            OMAttribute attribute = (OMAttribute) allAddrAttributes.next();
            addressAttributes.add(attribute);
        }
        OMElement refParamElement = eprOMElement
                .getFirstChildWithName(new QName(AddressingConstants.EPR_REFERENCE_PARAMETERS));
        if (refParamElement != null) {
            Iterator refParams = refParamElement.getChildElements();
            while (refParams.hasNext()) {
                OMElement omElement = (OMElement) refParams.next();
                addReferenceParameter(omElement);
            }
        }
        OMElement metaDataElement = eprOMElement
                .getFirstChildWithName(new QName(AddressingConstants.Final.WSA_METADATA));
        if (metaDataElement != null) {
            Iterator children = metaDataElement.getChildren();
            while (children.hasNext()) {
                OMNode omNode = (OMNode) children.next();
                addMetaData(omNode);
            }
        }
        setName(eprOMElement.getLocalName());
        Iterator allAttributes = eprOMElement.getAllAttributes();
        if (attributes == null) {
            attributes = new ArrayList();
        }
        while (allAttributes.hasNext()) {
            OMAttribute attribute = (OMAttribute) allAttributes.next();
            attributes.add(attribute);
        }
        Iterator childElements = eprOMElement.getChildElements();
        while (childElements.hasNext()) {
            OMElement eprChildElement = (OMElement) childElements.next();
            String localName = eprChildElement.getLocalName();
            if (!localName.equals("Address") &&
                    !localName.equals(AddressingConstants.EPR_REFERENCE_PARAMETERS) &&
                    !localName.equals(AddressingConstants.Final.WSA_METADATA)) {
                addExtensibleElement(eprChildElement);
            }
        }
}

 public String getAddress() 
{
        return address;
}

 public ArrayList getAddressAttributes() 
{
        return addressAttributes;
}

 public Map getAllReferenceParameters() 
{
        return referenceParameters;
}

This will return a Map of reference parameters with QName as the key and an OMElement as the value

 public ArrayList getAttributes() 
{
        return attributes;
}

 public ArrayList getExtensibleElements() 
{
        return extensibleElements;
}

 public String getLogCorrelationIDString() 
{
        if (logCorrelationIDString == null) {
            logCorrelationIDString = myClassName + "@" + UUIDGenerator.getUUID();
        }
        return logCorrelationIDString;
}

Get the ID associated with this object instance.

 public ArrayList getMetaData() 
{
        return metaData;
}

 public ArrayList getMetadataAttributes() 
{
        return metaDataAttributes;
}

 public String getName() 
{
        return name;
}

 public boolean hasAnonymousAddress() 
{
        boolean result = isWSAddressingAnonymous();
        if(!result && address != null) {
        	// If the address is not WS-A anonymous it might still be considered anonymous
        	// Avoid synchronization by using the
            // technique outlined at http://is.gd/gv3
        	List< String > localList = anonymousEquivalentURIs;
        	if(!localList.isEmpty()){
        		Iterator< String > it = localList.iterator();
        		while(it.hasNext()){
        			result = address.startsWith((String)it.next());
        			if(result){
        				break;
        			}
        		}	
        	}    	
        }
        if (log.isTraceEnabled()) {
            log.trace("hasAnonymousAddress: " + address + " is Anonymous: " + result);
        }
        return result;
}

This method is used to identify when response messages should be sent using the back channel of a two-way transport.

 public boolean hasNoneAddress() 
{
        boolean result = AddressingConstants.Final.WSA_NONE_URI.equals(address);
        if (log.isTraceEnabled()) {
            log.trace("hasNoneAddress: " + address + " is None: " + result);
        }
        return result;
}

hasNoneAddress

 public boolean isEquivalent(EndpointReference epr) 
{
        // NOTE: the input object is expected to exist (ie, be non-null)
        if ((this.name != null) && (epr.getName() != null)) {
            if (!this.name.equals(epr.getName())) {
                return false;
            }
        } else if ((this.name == null) && (epr.getName() == null)) {
            // continue
        } else {
            // mismatch
            return false;
        }
        if ((this.address != null) && (epr.getAddress() != null)) {
            if (!this.address.equals(epr.getAddress())) {
                return false;
            }
        } else if ((this.address == null) && (epr.getAddress() == null)) {
            // continue
        } else {
            // mismatch
            return false;
        }
        // TODO: is a strict test ok to use?
        ArrayList< OMNode > eprMetaData = epr.getMetaData();
        if ((this.metaData != null) && (eprMetaData != null)) {
            if (!this.metaData.equals(eprMetaData)) {
                // This is a strict test
                // Returns true if and only if the specified object
                // is also a list, both lists have the same size, and
                // all corresponding pairs of elements in the two lists
                // are equal, ie, two lists are defined to be equal if
                // they contain the same elements in the same order.
                return false;
            }
        } else if ((this.metaData == null) && (eprMetaData == null)) {
            // keep going
        } else {
            // one of the lists is null
            return false;
        }
        ArrayList< OMElement > eprExtensibleElements = epr.getExtensibleElements();
        if ((this.extensibleElements != null) && (eprExtensibleElements != null)) {
            if (!this.extensibleElements.equals(eprExtensibleElements)) {
                // This is a strict test
                // Returns true if and only if the specified object
                // is also a list, both lists have the same size, and
                // all corresponding pairs of elements in the two lists
                // are equal, ie, two lists are defined to be equal if
                // they contain the same elements in the same order.
                return false;
            }
        } else if ((this.extensibleElements == null) && (eprExtensibleElements == null)) {
            // keep going
        } else {
            // one of the lists is null
            return false;
        }
        ArrayList< OMAttribute > eprAttributes = epr.getAttributes();
        if ((this.attributes != null) && (eprAttributes != null)) {
            if (!this.attributes.equals(eprAttributes)) {
                // This is a strict test
                // Returns true if and only if the specified object
                // is also a list, both lists have the same size, and
                // all corresponding pairs of elements in the two lists
                // are equal, ie, two lists are defined to be equal if
                // they contain the same elements in the same order.
                return false;
            }
        } else if ((this.attributes == null) && (eprAttributes == null)) {
            // keep going
        } else {
            // one of the lists is null
            return false;
        }
        // TODO: check the Map referenceParameters for equivalency
        return true;
}

Compares key parts of the state from the current instance of this class with the specified instance to see if they are equivalent.

This differs from the java.lang.Object.equals() method in that the equals() method generally looks at both the object identity (location in memory) and the object state (data).

 public boolean isWSAddressingAnonymous() 
{
        return (AddressingConstants.Final.WSA_ANONYMOUS_URL.equals(address) ||
                AddressingConstants.Submission.WSA_ANONYMOUS_URL.equals(address));
}

This method identifies whether the address is a WS-Addressing spec defined anonymous URI.

 public  void readExternal(ObjectInput inObject) throws ClassNotFoundException, IOException 
{
        SafeObjectInputStream in = SafeObjectInputStream.install(inObject);
        // revision ID
        int revID = in.readInt();
        // make sure the object data is in a revision level we can handle
        if (revID != REVISION_2) {
            throw new ClassNotFoundException(ExternalizeConstants.UNSUPPORTED_REVID);
        }
        // String object id
        logCorrelationIDString = (String) in.readObject();
        // Read xml content
        in.readUTF(); // read marker
        int numBytes = in.readInt();
        byte[] serBytes = new byte[numBytes];
        // read the data from the input stream
        int bytesRead = 0;
        int numberOfBytesLastRead;
        while (bytesRead <  numBytes) {
            numberOfBytesLastRead = in.read(serBytes, bytesRead, numBytes - bytesRead);
            if (numberOfBytesLastRead == -1) {
                // TODO: What should we do if the reconstitution fails?
                // For now, log the event and throw an exception
                if (log.isDebugEnabled()) {
                    log.debug("readObject(): EPR logCorrelationID ["+logCorrelationIDString+"] "    
                            + " ***WARNING*** unexpected end to data:    data read from input stream ["
                            + bytesRead + "]    expected data size [" + numBytes + "]");
                }
                IOException ioe = new IOException("Unable to deserialize the EndpointReference with logCorrelationID ["
                                                  +logCorrelationIDString+"]"
                                                  +"  Cause: Unexpected end to data from input stream"); 
                throw ioe;
            }
            bytesRead += numberOfBytesLastRead;
        }
        if (bytesRead == 0) {
            IOException ioe = new IOException("Unable to deserialize the EndpointReference with logCorrelationID ["
                                              +logCorrelationIDString+"]"
                                              +"  Cause: No data from input stream"); 
            throw ioe;
        }
        in.readUTF(); // read marker
        ByteArrayInputStream bais = new ByteArrayInputStream(serBytes);
        if (log.isDebugEnabled()) {
            String content = new String(serBytes);
            log.debug("readObject(): EPR logCorrelationID ["+logCorrelationIDString+"] "    
                      +"    expected content size ["+numBytes+"]"
                      +"    content size ["+content.length()+"]"
                      +"    EPR buffered content ["+content+"]"); 
        }
        XMLStreamReader xmlReader = null;
        try {
            xmlReader = StAXUtils.createXMLStreamReader(bais);
            StAXOMBuilder builder = new StAXOMBuilder(xmlReader);
            OMElement om = builder.getDocumentElement();
            // expand the OM so we can close the stream reader
            om.build();
            // trace point
            if (log.isDebugEnabled()) {
                log.debug(myClassName + ":readObject():  "  
                          + " EPR ["+logCorrelationIDString + "]"
                          + " EPR OM content ["+om.toString()+ "]");
            }
            EndpointReferenceHelper.fromOM(this, om, AddressingConstants.Final.WSA_NAMESPACE);
        } catch (Exception e) {
            IOException ioe = new IOException("Unable to deserialize the EndpointReference with logCorrelationID ["
                                              +logCorrelationIDString+"]"); 
            ioe.initCause(e);
            if (log.isDebugEnabled()) {
                log.debug("readObject(): Unable to deserialize the EPR with logCorrelationID ["
                          +logCorrelationIDString+"]   original error ["+e.getClass().getName()
                          +"]  message ["+e.getMessage()+"]",e);  
            }
            throw ioe;
        } finally {
        	// Make sure that the reader is properly closed
            // Note that closing a ByteArrayInputStream has no effect
            if (xmlReader != null) {
                try {
                    xmlReader.close();
                } catch (Exception e2) {
                    IOException ioe2 = new IOException("Unable to close the XMLStreamReader for the EndpointReference with logCorrelationID ["
                                                      +logCorrelationIDString+"]"); 
                    ioe2.initCause(e2);
                    if (log.isDebugEnabled()) {
                        log.debug("readObject(): Unable to close the XMLStreamReader for the EPR with logCorrelationID ["
                                  +logCorrelationIDString+"]   original error ["+e2.getClass().getName()
                                  +"]  message ["+e2.getMessage()+"]",e2);  
                    }
                    throw ioe2;
                }
            }
        }
}

Read the EPR to the specified InputStream.

 public  void setAddress(String address) 
{
        this.address = address;
}

 public  void setAddressAttributes(ArrayList al) 
{
        addressAttributes = al;
}

 public  void setExtensibleElements(ArrayList extensibleElements) 
{
        this.extensibleElements = extensibleElements;
}

{any}

 public  void setMetadataAttributes(ArrayList al) 
{
        metaDataAttributes = al;
}

 public  void setName(String name) 
{
        this.name = name;
}

 public  void setReferenceParameters(Map referenceParameters) 
{
        this.referenceParameters = referenceParameters;
}

Set a Map with QName as the key and an OMElement as the value

 public OMElement toOM(String nsurl,
    String localName,
    String prefix) throws AxisFault 
{
        OMFactory fac = OMAbstractFactory.getOMFactory();
        if (prefix != null) {
            OMNamespace wrapNs = fac.createOMNamespace(nsurl, prefix);
            OMElement epr = fac.createOMElement(localName, wrapNs);
            OMNamespace wsaNS = fac.createOMNamespace(AddressingConstants.Final.WSA_NAMESPACE,
                                                      AddressingConstants.WSA_DEFAULT_PREFIX);
            OMElement addressE = fac.createOMElement(AddressingConstants.EPR_ADDRESS, wsaNS, epr);
            addressE.setText(address);
            if (addressAttributes != null) {
                Iterator attrIter = addressAttributes.iterator();
                while (attrIter.hasNext()) {
                    OMAttribute omAttributes = (OMAttribute) attrIter.next();
                    addressE.addAttribute(omAttributes);
                }
            }
            if (this.metaData != null) {
                OMElement metadataE =
                        fac.createOMElement(AddressingConstants.Final.WSA_METADATA, wsaNS, epr);
                Iterator metadata = this.metaData.iterator();
                while (metadata.hasNext()) {
                    metadataE.addChild((OMNode) metadata.next());
                }
            }
            if (this.referenceParameters != null) {
                OMElement refParameterElement =
                        fac.createOMElement(AddressingConstants.EPR_REFERENCE_PARAMETERS,
                                            wsaNS,
                                            epr);
                Iterator refParms = referenceParameters.values().iterator();
                while (refParms.hasNext()) {
                    refParameterElement.addChild((OMNode) refParms.next());
                }
            }
            if (attributes != null) {
                Iterator attrIter = attributes.iterator();
                while (attrIter.hasNext()) {
                    OMAttribute omAttributes = (OMAttribute) attrIter.next();
                    epr.addAttribute(omAttributes);
                }
            }
            // add xs:any
            ArrayList omElements = extensibleElements;
            if (omElements != null) {
                for (int i = 0; i <  omElements.size(); i++) {
                    epr.addChild((OMElement) omElements.get(i));
                }
            }
            return epr;
        } else {
            throw new AxisFault("prefix must be specified");
        }
}

 public String toString() 
{
        StringBuffer buffer = new StringBuffer("Address: " + address);
        if (addressAttributes != null) {
            buffer.append(", Address Attributes: ").append(addressAttributes);
        }
        if (metaData != null) {
            buffer.append(", Metadata: ").append(metaData);
        }
        if (metaDataAttributes != null) {
            buffer.append(", Metadata Attributes: ").append(metaDataAttributes);
        }
        if (referenceParameters != null) {
            buffer.append(", Reference Parameters: ").append(referenceParameters);
        }
        if (extensibleElements != null) {
            buffer.append(", Extensibility elements: ").append(extensibleElements);
        }
        if (attributes != null) {
            buffer.append(", Attributes: ").append(attributes);
        }
        return buffer.toString();
}

 public synchronized  void writeExternal(ObjectOutput o) throws IOException 
{
        SafeObjectOutputStream out = SafeObjectOutputStream.install(o);
        // revision ID
        out.writeInt(revisionID);
        // Correlation ID
        String logCorrelationIDString = getLogCorrelationIDString();
        // String object id
        out.writeObject(logCorrelationIDString);
        // Write out the content as xml
        out.writeUTF("start xml"); // write marker
        OMElement om =
                EndpointReferenceHelper.toOM(OMAbstractFactory.getOMFactory(),
                                             this,
                                             new QName("urn:axis2", "omepr", "ser"),
                                             AddressingConstants.Final.WSA_NAMESPACE);
        ByteArrayOutputStream baos = new ByteArrayOutputStream();
        try {
            om.serialize(baos);
        } catch (Exception e) {
            IOException ioe = new IOException("Unable to serialize the EndpointReference with logCorrelationID ["
                                              +logCorrelationIDString+"]"); 
            ioe.initCause(e);
            if (log.isDebugEnabled()) {
                log.debug("writeObject(): Unable to serialize the EPR with logCorrelationID ["
                          +logCorrelationIDString+"]   original error ["+e.getClass().getName()
                          +"]  message ["+e.getMessage()+"]",e);  
            }
            throw ioe;
        }
        out.writeInt(baos.size());
        out.write(baos.toByteArray());  
        out.writeUTF("end xml"); // write marker
        if (log.isDebugEnabled()) {
            byte[] buffer = baos.toByteArray();
            String content = new String(buffer);
            log.debug("writeObject(): EPR logCorrelationID ["+logCorrelationIDString+"] "    
                      +"    EPR content size ["+baos.size()+"]"
                      +"    EPR content ["+content+"]"); 
        }
}

Write the EPR to the specified OutputStream. Because of potential OMElements/Attributes, we need to actually serialize the OM structures (at least in some cases.)