src/java/org/opensrf/net/xmpp/XMPPMessage.java

   1 package org.opensrf.net.xmpp;
   2
   3 import java.io.*;
   4
   5
   6 /*
   7  * uncomment to use the DOM serialization code...
   8
   9 import org.w3c.dom.*;
  10 import org.apache.xerces.dom.DocumentImpl;
  11 import org.apache.xerces.dom.DOMImplementationImpl;
  12 import org.apache.xml.serialize.OutputFormat;
  13 import org.apache.xml.serialize.Serializer;
  14 import org.apache.xml.serialize.SerializerFactory;
  15 import org.apache.xml.serialize.XMLSerializer;
  16 */
  17
  18
  19 /**
  20  * Models a single XMPP message.
  21  */
  22 public class XMPPMessage {
  23
  24     /** Message body */
  25     private String body;
  26     /** Message recipient */
  27     private String to;
  28     /** Message sender */
  29     private String from;
  30     /** Message thread */
  31     private String thread;
  32     /** Message xid */
  33     private String xid;
  34
  35     public XMPPMessage() {
  36     }
  37
  38     public String getBody() {
  39         return body;
  40     }
  41     public String getTo() {
  42         return to;
  43     }
  44     public String getFrom() {
  45         return from;
  46     }
  47     public String getThread() {
  48         return thread;
  49     }
  50     public String getXid() {
  51         return xid;
  52     }
  53     public void setBody(String body) {
  54         this.body = body;
  55     }
  56     public void setTo(String to) {
  57         this.to = to;
  58     }
  59     public void setFrom(String from) {
  60         this.from = from;
  61     }
  62     public void setThread(String thread) {
  63         this.thread = thread;
  64     }
  65     public void setXid(String xid) {
  66         this.xid = xid;
  67     }
  68
  69
  70     /**
  71      * Generates the XML representation of this message.
  72      */
  73     public String toXML() {
  74         StringBuffer sb = new StringBuffer("<message to='");
  75         escapeXML(to, sb);
  76         sb.append("' osrf_xid='");
  77         escapeXML(xid, sb);
  78         sb.append("'><thread>");
  79         escapeXML(thread, sb);
  80         sb.append("</thread><body>");
  81         escapeXML(body, sb);
  82         sb.append("</body></message>");
  83         return sb.toString();
  84     }
  85
  86
  87     /**
  88      * Escapes non-valid XML characters.
  89      * @param s The string to escape.
  90      * @param sb The StringBuffer to append new data to.
  91      */
  92     private void escapeXML(String s, StringBuffer sb) {
  93         if( s == null ) return;
  94         char c;
  95         int l = s.length();
  96         for( int i = 0; i < l; i++ ) {
  97             c = s.charAt(i);
  98             switch(c) {
  99                 case '<':
 100                     sb.append("&lt;");
 101                     break;
 102                 case '>':
 103                     sb.append("&gt;");
 104                     break;
 105                 case '&':
 106                     sb.append("&amp;");
 107                     break;
 108                 default:
 109                     sb.append(c);
 110             }
 111         }
 112     }
 113
 114
 115
 116     /**
 117      * This is a DOM implementataion of message serialization.
 118      * I'm inclined to think the stringbuffer version is faster, but
 119      * I have no proof.
 120      */
 121     /*
 122     public String __toXML() {
 123
 124         Document doc = new DocumentImpl();
 125         Element message = doc.createElement("message");
 126         Element body = doc.createElement("body");
 127         Element thread = doc.createElement("thread");
 128
 129         doc.appendChild(message);
 130         message.setAttribute("to", getTo());
 131         message.setAttribute("from", getFrom());
 132         message.appendChild(body);
 133         message.appendChild(thread);
 134
 135         body.appendChild(doc.createTextNode(getBody()));
 136         thread.appendChild(doc.createTextNode(getThread()));
 137
 138         XMLSerializer serializer = new XMLSerializer();
 139         StringWriter strWriter = new StringWriter();
 140         OutputFormat outFormat = new OutputFormat();
 141
 142         outFormat.setEncoding("UTF-8");
 143         outFormat.setVersion("1.0");
 144         outFormat.setIndenting(false);
 145         outFormat.setOmitXMLDeclaration(true);
 146
 147         serializer.setOutputCharStream(strWriter);
 148         serializer.setOutputFormat(outFormat);
 149
 150         try {
 151             serializer.serialize(doc);
 152         } catch(IOException ioe) {
 153         }
 154         return strWriter.toString();
 155     }
 156     */
 157 }
 158
 159