sjero.net Git - linphone/blob - p2pproxy/dependencies-src/jxse-src-2.5/impl/src/net/jxta/impl/endpoint/JxtaMessageMessageElement.java

   1 /*
   2  * Copyright (c) 2001-2007 Sun Microsystems, Inc.  All rights reserved.
   3  *
   4  *  The Sun Project JXTA(TM) Software License
   5  *
   6  *  Redistribution and use in source and binary forms, with or without
   7  *  modification, are permitted provided that the following conditions are met:
   8  *
   9  *  1. Redistributions of source code must retain the above copyright notice,
  10  *     this list of conditions and the following disclaimer.
  11  *
  12  *  2. Redistributions in binary form must reproduce the above copyright notice,
  13  *     this list of conditions and the following disclaimer in the documentation
  14  *     and/or other materials provided with the distribution.
  15  *
  16  *  3. The end-user documentation included with the redistribution, if any, must
  17  *     include the following acknowledgment: "This product includes software
  18  *     developed by Sun Microsystems, Inc. for JXTA(TM) technology."
  19  *     Alternately, this acknowledgment may appear in the software itself, if
  20  *     and wherever such third-party acknowledgments normally appear.
  21  *
  22  *  4. The names "Sun", "Sun Microsystems, Inc.", "JXTA" and "Project JXTA" must
  23  *     not be used to endorse or promote products derived from this software
  24  *     without prior written permission. For written permission, please contact
  25  *     Project JXTA at http://www.jxta.org.
  26  *
  27  *  5. Products derived from this software may not be called "JXTA", nor may
  28  *     "JXTA" appear in their name, without prior written permission of Sun.
  29  *
  30  *  THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED WARRANTIES,
  31  *  INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
  32  *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL SUN
  33  *  MICROSYSTEMS OR ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  34  *  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  35  *  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,
  36  *  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
  37  *  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
  38  *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
  39  *  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  40  *
  41  *  JXTA is a registered trademark of Sun Microsystems, Inc. in the United
  42  *  States and other countries.
  43  *
  44  *  Please see the license information page at :
  45  *  <http://www.jxta.org/project/www/license.html> for instructions on use of
  46  *  the license in source files.
  47  *
  48  *  ====================================================================
  49  *
  50  *  This software consists of voluntary contributions made by many individuals
  51  *  on behalf of Project JXTA. For more information on Project JXTA, please see
  52  *  http://www.jxta.org.
  53  *
  54  *  This license is based on the BSD license adopted by the Apache Foundation.
  55  */
  56
  57 package net.jxta.impl.endpoint;
  58
  59
  60 import java.io.ByteArrayOutputStream;
  61 import java.io.IOException;
  62 import java.io.InputStream;
  63 import java.io.OutputStream;
  64
  65 import java.util.logging.Level;
  66 import net.jxta.logging.Logging;
  67 import java.util.logging.Logger;
  68
  69 import net.jxta.document.MimeMediaType;
  70 import net.jxta.endpoint.Message;
  71 import net.jxta.endpoint.MessageElement;
  72 import net.jxta.endpoint.WireFormatMessageFactory;
  73
  74
  75 /**
  76  * A Message Element using a JXTA Message as the element data
  77  *
  78  *  @see net.jxta.endpoint.Message
  79  *  @see net.jxta.endpoint.MessageElement
  80  **/
  81 public class JxtaMessageMessageElement extends MessageElement {
  82
  83     /**
  84      *  Log4J Logger
  85      **/
  86     private final static transient Logger LOG = Logger.getLogger(JxtaMessageMessageElement.class.getName());
  87
  88     /**
  89      *  The Message which is the data for this message element.
  90      **/
  91     protected final Message msg;
  92
  93     /**
  94      *  A serialized form of the message.
  95      **/
  96     protected transient net.jxta.endpoint.WireFormatMessage serial;
  97
  98     /**
  99      * Create a new Message Element. The contents of the provided message are
 100      * <b>not</b> copied during construction.
 101      *
 102      * @param name Name of the MessageElement. May be the empty string ("") if
 103      * the MessageElement is not named.
 104      * @param type Type of the MessageElement. null is the same as specifying
 105      * the type "Application/Octet-stream".
 106      * @param msg A message which will be used as the element content for this
 107      * message.
 108      * @param sig optional message digest/digital signature element or null if
 109      * no signature is desired.
 110      **/
 111     public JxtaMessageMessageElement(String name, MimeMediaType type, Message msg, MessageElement sig) {
 112         super(name, type, sig);
 113
 114         this.msg = msg;
 115     }
 116
 117     /**
 118      *  {@inheritDoc}
 119      **/
 120     @Override
 121     public boolean equals(Object target) {
 122         if (this == target) {
 123             return true;
 124         }
 125
 126         if (target instanceof MessageElement) {
 127             if (!super.equals(target)) {
 128                 return false;
 129             }
 130
 131             if (target instanceof JxtaMessageMessageElement) {
 132                 JxtaMessageMessageElement likeMe = (JxtaMessageMessageElement) target;
 133
 134                 return super.equals(likeMe) && msg.equals(likeMe.msg);
 135             } else {
 136                 // have to do a slow stream comparison.
 137                 // XXX 20020615 bondolo@jxta.org the performance of this could be much improved.
 138                 try {
 139                     MessageElement likeMe = (MessageElement) target;
 140
 141                     InputStream myStream = getStream();
 142                     InputStream itsStream = likeMe.getStream();
 143
 144                     int mine;
 145                     int its;
 146
 147                     do {
 148                         mine = myStream.read();
 149                         its = itsStream.read();
 150
 151                         if (mine != its) {
 152                             return false;
 153                         }       // content didn't match (includes EOF check).
 154
 155                     } while (-1 != mine);
 156
 157                     return true;
 158                 } catch (IOException fatal) {
 159                     if (Logging.SHOW_SEVERE && LOG.isLoggable(Level.SEVERE)) {
 160                         LOG.log(Level.SEVERE, "MessageElements could not be compared.", fatal);
 161                     }
 162
 163                     IllegalStateException failure = new IllegalStateException("MessageElements could not be compared.");
 164
 165                     failure.initCause(fatal);
 166
 167                     throw failure;
 168                 }
 169             }
 170         }
 171
 172         return false; // not a message element
 173     }
 174
 175     /**
 176      *  {@inheritDoc}
 177      **/
 178     @Override
 179     public int hashCode() {
 180         int result = super.hashCode() * 6037 + // a prime
 181                 msg.hashCode();
 182
 183         return (0 != result) ? result : 1;
 184     }
 185
 186     /**
 187      *  {@inheritDoc}
 188      **/
 189     @Override
 190     public String toString() {
 191         throw new UnsupportedOperationException("Cannot Generate String for this message element type.");
 192     }
 193
 194     /**
 195      *  {@inheritDoc}
 196      **/
 197     @Override
 198     public long getByteLength() {
 199         initSerial();
 200
 201         return serial.getByteLength();
 202     }
 203
 204     /**
 205      *  {@inheritDoc}
 206      **/
 207     @Override
 208     public byte[] getBytes(boolean copy) {
 209         initSerial();
 210
 211         ByteArrayOutputStream baos = new ByteArrayOutputStream((int) serial.getByteLength());
 212
 213         try {
 214             sendToStream(baos);
 215
 216             baos.close();
 217         } catch (IOException failed) {
 218             throw new IllegalStateException("failed to generate byte stream");
 219         }
 220
 221         return baos.toByteArray();
 222     }
 223
 224     /**
 225      *  {@inheritDoc}
 226      **/
 227     public InputStream getStream() throws IOException {
 228         initSerial();
 229
 230         return serial.getStream();
 231     }
 232
 233     /**
 234      *  {@inheritDoc}
 235      **/
 236     @Override
 237     public void sendToStream(OutputStream sendTo) throws IOException {
 238         initSerial();
 239
 240         serial.sendToStream(sendTo);
 241     }
 242
 243     /**
 244      *  Returns a copy of the message which backs this element.
 245      *
 246      *  @return Returns a copy of the message which backs this element.
 247      **/
 248     public Message getMessage() {
 249         return msg.clone();
 250     }
 251
 252     /**
 253      *  Generates the serialized representation of the message.
 254      **/
 255     private synchronized void initSerial() {
 256         if (null == serial) {
 257             serial = WireFormatMessageFactory.toWire(msg, type, null);
 258         }
 259     }
 260 }