Iterator allLineage = getMessageLineage();         while( allLineage.hasNext() ) {            toString.append( allLineage.next().toString() );            if( allLineage.hasNext() ) {                toString.append( ',' );            }        }                toString.append( '}' );                if( GLOBAL_TRACKING_ELEMENT ) {            toString.append( "[" );            Iterator eachUUID = getMessageElements( "jxta", "Tracking UUID" );                        while( eachUUID.hasNext() ) {            toString.append( "[" );                toString.append( eachUUID.next().toString() );            toString.append( "]" );                if( eachUUID.hasNext() ) {                toString.append( ',' );            }            }            toString.append( "]" );        }                return toString.toString();    }        /**     *  Read this Object in for Java Serialization     *     *  @param s The stream from which the Object will be read.     *  @throws IOException for errors reading from the input stream.     *  @throws ClassNotFoundException if the serialized representation contains     *  references to classes which cannot be found.     **/    private void readObject( ObjectInputStream s ) throws IOException, ClassNotFoundException {        // reads defaultNamespace, modifiable flag        s.defaultReadObject();                MimeMediaType readType = new MimeMediaType( s.readUTF() );                // XXX bondolo 20040307 Should do something with encoding here.                Message readMessage = WireFormatMessageFactory.fromWire( s, readType, null );                namespaces = readMessage.namespaces;        elements = readMessage.elements;        if( elements.contains( defaultNamespace ) ) {            throw new IOException( "Corrupted Object--does not contain required namespace."  );        }                properties = new HashMap();        lineage = new ArrayList();                lineage.add( new Integer( getNextMessageNumber() ) );                if ( LOG_MODIFICATIONS ) {            modHistory = new ArrayList();            incMessageModCount();        }    }        /**     *  Write this Object out for Java Serialization     *     *  @param s The stream to which the Object will be written.     *  @throws IOException for errors writing to the output stream.     **/    private void writeObject( ObjectOutputStream s ) throws IOException {        s.defaultWriteObject();                MimeMediaType writeType = WireFormatMessageFactory.DEFAULT_WIRE_MIME;                s.writeUTF( writeType.toString() );                // XXX bondolo 20040307 Should do something with encoding here.                WireFormatMessage serialed = WireFormatMessageFactory.toWire( this, writeType, null );                serialed.sendToStream( s );    }        /**     * Return the default Namespace of this message.     *     * @return The default namespace for this message.     **/    protected String getDefaultNamespace() {        return defaultNamespace;    }        /**     *  Add a MessageElement into the message. The MessageElement is stored in     * the default namespace.     *     *  @param add the Element to add to the message.     **/    public void addMessageElement( MessageElement add ) {                addMessageElement( null, add );    }        /**     *  Add a MessageElement into the message using the specified namespace.     *     *  @param namespace contains the namespace of the element to add. You can     *  specify null as a shorthand for the default namespace.     *  @param add the MessageElement to add to the message.     **/    public void addMessageElement( String namespace, MessageElement add ) {        if( null == namespace ) {            namespace = getDefaultNamespace();        }                if( null == add ) {            throw new IllegalArgumentException( "Message Element must be non-null" );        }                elements.add( new element( namespace, add ) );                List namespaceElements = (List) namespaces.get( namespace );        if( null == namespaceElements ) {            namespaceElements = new ArrayList();            namespaces.put( namespace, namespaceElements );        }                namespaceElements.add( add );        incMessageModCount();        if (LOG.isEnabledFor(Level.DEBUG)) {            LOG.debug("Added " + namespace + "::" + add.getElementName() + "/" + add.getClass().getName() + "@" + add.hashCode() + " to " + this );        }    }        /**     * Replace a {@link net.jxta.endpoint.MessageElement} in the message. This method will remove     * all MessageElement instances in the default namespace which match the     * specified name (if any) and then insert the replacement element. The     * existing version of the element is returned, if more than one matching     * element was removed, a random matching element is returned.     *     *  <p/>For greatest control over element replacement, use the     *  {@link java.util.ListIterator#set(java.lang.Object)} method as returned     *  by {@link #getMessageElements()},     *  {@link #getMessageElements(java.lang.String)} or     *  {@link #getMessageElementsOfNamespace(java.lang.String)}     *     *  @param replacement the Element to be inserted into to the message.     *  @return One of the elements which was replaced or null if no existing     *  matching item was located.     **/    public MessageElement replaceMessageElement( MessageElement replacement ) {        return replaceMessageElement( null, replacement );    }        /**     *  Replace a {@link net.jxta.endpoint.MessageElement} in the message using the specified     *  namespace. This method will remove all MessageElement instances which     *  match the specified name (if any) and then insert the replacement     *  element. The existing version of the element is returned, if more than     *  one matching element was removed, a random matching element is returned.     *     *  <p/>For greatest control over element replacement, use the     *  {@link java.util.ListIterator#set(java.lang.Object)} method as returned     *  by {@link #getMessageElements()},     *  {@link #getMessageElements(java.lang.String)} or     *  {@link #getMessageElementsOfNamespace(java.lang.String)}     *     *  @param namespace contains the namespace of the element to be replaced.     *  You can specify null as a shorthand for the default namespace.     *  @param replacement the Element to be inserted into to the message.     *  @return One of the elements which was replaced or null if no existing     *  matching item was located.     **/    public MessageElement replaceMessageElement( String namespace, MessageElement replacement ) {        if( null == namespace ) {            namespace = getDefaultNamespace();        }                if( null == replacement ) {            throw new IllegalArgumentException( "Message Element must be non-null" );        }                MessageElement removed = null;        Iterator allMatching = getMessageElements( namespace, replacement.getElementName() );                while( allMatching.hasNext() ) {            MessageElement anElement = (MessageElement) allMatching.next();            allMatching.remove();            removed = anElement;        }                addMessageElement( namespace, replacement ); // updates mod count                return removed;    }        /**     *  Returns an iterator of the namespaces present in this message. All of the     *  elements will be Strings.     *     *  @return iterator of strings of the namespaces of this message.     **/    public Iterator getMessageNamespaces( ) {        return Collections.unmodifiableMap(namespaces).keySet().iterator();    }        /**     *  Retrieve a element by name from the message without regard to     *  namespace. If there is more than one element with this name, a random     *  element will be returned.     *     *  @param name The name of the element to attept to retrieve.     *  @return Element the element or null if no matching element could be     *  found.     */    public MessageElement getMessageElement( String name ) {        Iterator eachElement = elements.listIterator();                while( eachElement.hasNext() ) {            element anElement = (element) eachElement.next();                        if( name.equals( anElement.element.getElementName() ) ) {                return anElement.element;            }        }                return null;    }        /**     *  Retrieve a element by name in the specified namespace from the message.     *  If there is more than one element with this name, a random     *  element will be returned.     *     *  @param namespace contains the namespace of the element to get. You can     *  specify null as a shorthand for the default namespace.     *  @param name contains the name of the element to get     *  @return Element the element.     **/    public MessageElement getMessageElement( String namespace, String name ) {        if( null == namespace ) {            namespace = getDefaultNamespace();        }                List namespaceElements = (List) namespaces.get( namespace );                // no namespace means no element.        if( null == namespaceElements ) {            return null;        }                Iterator eachElement = namespaceElements.listIterator();                while( eachElement.hasNext() ) {            MessageElement anElement = (MessageElement) eachElement.next();                        if( name.equals( anElement.getElementName() ) ) {                return anElement;            }        }                return null;    }        /**     *  Returns a list iterator of all of the elements contained in this message.     *  Elements from all namespaces are returned.     *     *  <p/>The iterator returned is not synchronized with the message and will     *  throw {@link java.util.ConcurrentModificationException} if the     *  message is modified.     *     *  @return Enumeration of Elements.     *     **/    public ElementIterator getMessageElements( ) {        Vector theMsgElements = new Vector( elements );                return new ElementIterator( theMsgElements.listIterator() );    }        /**     *  Returns a list iterator  of all of the elements contained in this     *  message who's name matches the specified name. Elements from all     *  namespaces are returned. Message Elements are iterated in the order in     *  which they were added to the Message.     *     *  <p/>The iterator returned is not synchronized with the message and will     *  throw {@link java.util.ConcurrentModificationException} if the     *  message is modified.     *     *  @param name the name of the elements to match against     *  @return iterator of the elements matching the specified name, if any.     */    public ElementIterator getMessageElements( String name ) {        List theMsgElements = new ArrayList( elements.size() );                Iterator eachElement = elements.iterator();                while ( eachElement.hasNext() ) {            element anElement = (element) eachElement.next();                        if( name.equals(anElement.element.getElementName()) ) {                theMsgElements.add( anElement );            }        }                return new ElementIterator( theMsgElements.listIterator() );    }        /**     *  Returns an list iterator  of all of the elements contained in this message     *  which match the specified namespace. Message Elements are iterated in     *  the order in which they were added to the Message.     *     *  <p/>This ListIterator returned is not synchronized with the message. If     *  you modify the state of the Message, the iterator will throw     *  ConcurrentModificationException when <code>next()</code> or     *  <code>previous()</code> is called.     *     *  <p/>The iterator returned is not synchronized with the message and will     *  throw {@link java.util.ConcurrentModificationException} if the     *  message is modified.     *     *  @param namespace contains the namespace which must be matched in the     *  elements returned. You can specify null as a shorthand for the default     *  namespace.     *  @return Enumeration of Elements.     **/    public ElementIterator getMessageElementsOfNamespace( String namespace ) {        List theMsgElements = new ArrayList( elements.size() );                if( null == namespace ) {            namespace = getDefaultNamespace();        }                Iterator eachElement = elements.iterator();                while ( eachElement.hasNext() ) {            element anElement = (element) eachElement.next();                        if( namespace.equals(anElement.namespace) ) {                theMsgElements.add( anElement );            }        }                return new ElementIterator( theMsgElements.listIterator() );    }        /**     *  Returns a list iterator  of all of the elements contained in the     *  specified namespace who's name matches the specified name in the order