sjero.net Git - linphone/blob - p2pproxy/dependencies-src/jxse-src-2.5/impl/src/net/jxta/impl/document/PlainTextDocument.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.document;
  58
  59
  60 import java.io.BufferedWriter;
  61 import java.io.ByteArrayInputStream;
  62 import java.io.InputStream;
  63 import java.io.OutputStream;
  64 import java.io.OutputStreamWriter;
  65 import java.io.Reader;
  66 import java.io.StringReader;
  67 import java.io.StringWriter;
  68 import java.io.Writer;
  69
  70 import java.io.IOException;
  71 import java.security.ProviderException;
  72
  73 import net.jxta.document.MimeMediaType;
  74 import net.jxta.document.StructuredDocument;
  75 import net.jxta.document.StructuredDocumentFactory;
  76 import net.jxta.document.StructuredTextDocument;
  77 import net.jxta.document.TextElement;
  78 import net.jxta.document.TextDocument;
  79
  80
  81 /**
  82  * This class is an implementation of the StructuredDocument interface using
  83  * simple text
  84  */
  85 public class PlainTextDocument extends PlainTextElement implements StructuredTextDocument<PlainTextElement> {
  86
  87     private final static class Instantiator implements StructuredDocumentFactory.TextInstantiator {
  88
  89         /**
  90          * The MIME Media Types which this <CODE>StructuredDocument</CODE> is
  91          * capable of emitting.
  92          */
  93         private static final MimeMediaType[] myTypes = {
  94             MimeMediaType.TEXT_DEFAULTENCODING
  95         };
  96
  97         // these are the file extensions which are likely to contain files of
  98         // the type i like.
  99         private static final ExtensionMapping[] myExtensions = {
 100             new ExtensionMapping("txt", myTypes[0]), new ExtensionMapping("text", myTypes[0]), new ExtensionMapping("txt", null) };
 101
 102         /**
 103          * Creates new PlainTextDocument
 104          */
 105         public Instantiator() {}
 106
 107         /**
 108          * {@inheritDoc}
 109          */
 110         public MimeMediaType[] getSupportedMimeTypes() {
 111             return (myTypes);
 112         }
 113
 114         /**
 115          * {@inheritDoc}
 116          */
 117         public ExtensionMapping[] getSupportedFileExtensions() {
 118             return (myExtensions);
 119         }
 120
 121         /**
 122          * {@inheritDoc}
 123          */
 124         public StructuredDocument newInstance(MimeMediaType mimeType, String doctype) {
 125             return new PlainTextDocument(mimeType, doctype);
 126         }
 127
 128         /**
 129          * {@inheritDoc}
 130          */
 131         public StructuredDocument newInstance(MimeMediaType mimeType, String doctype, String value) {
 132             return new PlainTextDocument(mimeType, doctype, value);
 133         }
 134
 135         /**
 136          * {@inheritDoc}
 137          */
 138         public StructuredDocument newInstance(MimeMediaType mimeType, InputStream source) throws IOException {
 139             throw new ProviderException("PlainTextDocument does not support input");
 140         }
 141
 142         /**
 143          * {@inheritDoc}
 144          */
 145         public StructuredDocument newInstance(MimeMediaType mimeType, Reader source) throws IOException {
 146             throw new ProviderException("PlainTextDocument does not support input");
 147         }
 148
 149     }
 150
 151     public static final StructuredDocumentFactory.TextInstantiator INSTANTIATOR = new Instantiator();
 152
 153     private MimeMediaType mimeType = null;
 154
 155     /**
 156      * Creates new PlainTextDocument
 157      */
 158     public PlainTextDocument(final MimeMediaType mimeType, String type) {
 159         super(null, type);
 160         doc = this;
 161         parent = this;
 162
 163         this.mimeType = mimeType;
 164     }
 165
 166     /**
 167      * Creates new PlainTextDocument with a value for the root element
 168      */
 169     public PlainTextDocument(final MimeMediaType mimeType, final String type, final String value) {
 170         super(null, type, value);
 171         doc = this;
 172         parent = this;
 173
 174         this.mimeType = mimeType;
 175     }
 176
 177     /**
 178      * {@inheritDoc}
 179      */
 180     @Override
 181     public String toString() {
 182         StringWriter stringOut = new StringWriter();
 183
 184         try {
 185             printNice(stringOut, 0, true);
 186             stringOut.close();
 187         } catch (IOException caught) {
 188             return null;
 189         }
 190
 191         return stringOut.toString();
 192     }
 193
 194     /**
 195      * get Type
 196      */
 197     public MimeMediaType getMimeType() {
 198         return mimeType;
 199     }
 200
 201     /**
 202      * {@inheritDoc}
 203      */
 204     public String getFileExtension() {
 205         return TextDocumentCommon.Utils.getExtensionForMime(INSTANTIATOR.getSupportedFileExtensions(), getMimeType());
 206     }
 207
 208     /**
 209      * {@inheritDoc}
 210      */
 211     public PlainTextElement createElement(Object key) {
 212         return createElement(key, null);
 213     }
 214
 215     /**
 216      * {@inheritDoc}
 217      */
 218     public PlainTextElement createElement(Object key, Object val) {
 219         if (!String.class.isAssignableFrom(key.getClass())) {
 220             throw new ClassCastException(key.getClass().getName() + " not supported by createElement.");
 221         }
 222
 223         if ((null != val) && !String.class.isAssignableFrom(val.getClass())) {
 224             throw new ClassCastException(val.getClass().getName() + " not supported by createElement.");
 225         }
 226
 227         return new PlainTextElement(this, (String) key, (String) val);
 228     }
 229
 230     /**
 231      * {@inheritDoc}
 232      */
 233     public PlainTextElement createElement(String name) {
 234         return new PlainTextElement(this, name);
 235     }
 236
 237     /**
 238      * {@inheritDoc}
 239      */
 240     public PlainTextElement createElement(String name, String val) {
 241         return new PlainTextElement(this, name, val);
 242     }
 243
 244     /**
 245      * {@inheritDoc}
 246      */
 247     public InputStream getStream() throws IOException {
 248         // XXX  bondolo@jxta.org 20010307    Should be using a pipe
 249         String charset = mimeType.getParameter("charset");
 250
 251         if (charset == null) {
 252             return new ByteArrayInputStream(toString().getBytes());
 253         } else {
 254             return new ByteArrayInputStream(toString().getBytes(charset));
 255         }
 256     }
 257
 258     /**
 259      * {@inheritDoc}
 260      */
 261     public void sendToStream(OutputStream stream) throws IOException {
 262         String charset = mimeType.getParameter("charset");
 263
 264         Writer osw;
 265
 266         if (charset == null) {
 267             osw = new OutputStreamWriter(stream);
 268         } else {
 269             osw = new OutputStreamWriter(stream, charset);
 270         }
 271
 272         Writer out = new BufferedWriter(osw);
 273
 274         sendToWriter(out);
 275         out.flush();
 276     }
 277
 278     /**
 279      * {@inheritDoc}
 280      */
 281     public Reader getReader() {
 282         // XXX  bondolo@jxta.org 20010307    Should be using a pipe
 283
 284         return new StringReader(toString());
 285     }
 286
 287     /**
 288      * {@inheritDoc}
 289      */
 290     public void sendToWriter(Writer stream) throws IOException {
 291         printNice(stream, 0, true);
 292     }
 293 }