* This list is never null, but can be empty.
* Every missing data handler implies there is an error,
* something is missing in the pay-load.
*
*/
public Set getOrphanContentIds() {
return this.orphanContentIds;
}
/**
* @return the list of data handlers that are not associated with a
* content ID.
*
* This list is never null, but can be empty.
* Every orphan data handler implies there is an error on the
* client side (SwA attachments are part of the pay-load). But
* this should not prevent the processing from being done. This
* method aims at describing the coherence of the pay-load with
* the attachments (and can be used for logging reasons).
*
*/
public List getOrphanDataHandlers() {
return this.orphanDataHandlers;
}
/**
* @param key
* a content ID, as specified by the XOP's cid
* @param value
* the associated data handler
* @return the previous value that was associated with this content ID
* @see java.util.Map#put(java.lang.Object, java.lang.Object)
*/
DataHandler put(String key, DataHandler value) {
return this.contentIdToDataHandler.put(key, value);
}
/**
* @param o
* a content ID, as specified by the XOP's cid
* @return true, if this content ID was not already stored
* @see java.util.Set#add(java.lang.Object)
*/
boolean add(String o) {
return this.orphanContentIds.add(o);
}
/**
* @param o
* a data handler which are associated with no content ID
* @return true if the data handler was not already in the list
* @see java.util.List#add(java.lang.Object)
*/
boolean add(DataHandler o) {
return this.orphanDataHandlers.add(o);
}
/**
* @param c
* a collection of data handlers which are associated with no
* content ID
* @return if this list changed as a result of the call
* @see java.util.List#add(java.lang.Object)
*/
boolean addAll(Collection c) {
return this.orphanDataHandlers.addAll(c);
}
}
/**
* Builds a MTOM mapping from both an exchange and a root element.
*
* @param exchange
* the message exchange
* @param element
* the element from which MTOM elements must be searched.
*
* MTOM elements are elements associated with the name space
* http://www.w3.org/2004/08/xop/include.
* If null, the root element of the pay-load is taken.
* If you already have extracted the pay-load as a document, you
* can use Document#getDocumentElement().
*
*
* @return null if the element is null and could not be built, a
* {@link MtomMapping} instance otherwise
* @throws MessagingException
* if something went wrong while acquiring the message content
*/
public static MtomMapping getMtomMapping(Exchange exchange, Element element) throws MessagingException {
MtomMapping result = null;
// Need an element? Take the root of the pay-load.
if (element == null) {
Document doc = exchange.getInMessageContentAsDocument(true);
if (doc != null && doc.getDocumentElement() != null)
element = doc.getDocumentElement();
}
// Get the mapping
if (element != null) {
result = new MtomMapping();
// Get all the content IDs from the pay-load
Set contentIds = MtomUtil.extractAttachmentsIdFromPayload(element);
List allTheDataHandlers = new ArrayList ();
for (String attName : exchange.getInMessageAttachmentNames()) {
allTheDataHandlers.add(exchange.getInMessageAttachment(attName));
}
// For each content ID, find the associated data handler.
// Keep a trace of orphan data handlers.
for (String contentId : contentIds) {
DataHandler dataHandler = null;
for (String attName : exchange.getInMessageAttachmentNames()) {
if (MtomUtil.compare(contentId, attName)) {
dataHandler = exchange.getInMessageAttachment(attName);
break;
}
}
if (dataHandler != null) {
allTheDataHandlers.remove(dataHandler);
result.put(contentId, dataHandler);
}
else {
result.add(contentId);
}
}
// Do not forget the orphan data handlers
result.addAll(allTheDataHandlers);
}
return result;
}
}