Esempio n. 1
0
 public Object getData() {
   if (type.isXMLType()) {
     return xmlDocument;
   } else if (type.isTextType()) {
     return plainText;
   } else { // audio
     return audio;
   }
 }
Esempio n. 2
0
 /**
  * Read data from input stream <code>is</code>, in the appropriate way as determined by our <code>
  * type</code>.
  *
  * @param is the InputStream from which to read.
  * @param endMarker a string marking end of file. If this is null, read until end-of-file; if it
  *     is non-null, read up to (and including) the first line containing the end marker string.
  *     This will be ignored for audio data.
  * @throws ParserConfigurationException ParserConfigurationException
  * @throws SAXException SAXException
  * @throws IOException IOException
  * @throws TransformerConfigurationException TransformerConfigurationException
  * @throws TransformerException TransformerException
  */
 public void readFrom(InputStream is, String endMarker)
     throws ParserConfigurationException, SAXException, IOException,
         TransformerConfigurationException, TransformerException {
   if (type.isXMLType() || type.isTextType())
     readFrom(new InputStreamReader(is, "UTF-8"), endMarker);
   else { // audio
     // ignore endMarker
     setAudio((AudioInputStream) is);
   }
 }
Esempio n. 3
0
 /**
  * Write our internal representation to writer <code>w</code>, in the appropriate way as
  * determined by our <code>type</code>. Only XML and Text data can be written to a writer, audio
  * data cannot. "Helpers" needed to read the data, such as XML parser objects, are created when
  * they are needed.
  *
  * @param w w
  * @throws TransformerConfigurationException TransformerConfigurationException
  * @throws FileNotFoundException FileNotFoundException
  * @throws TransformerException TransformerException
  * @throws IOException IOException
  * @throws Exception Exception
  */
 public void writeTo(Writer w)
     throws TransformerConfigurationException, FileNotFoundException, TransformerException,
         IOException, Exception {
   if (type.isXMLType()) {
     throw new IOException("Better write XML data to an OutputStream, not to a Writer");
   } else if (type.isTextType()) { // caution: XML types are text types!
     w.write(plainText);
     w.flush();
     logger.debug("Writing Text output:\n" + plainText);
   } else { // audio - cannot write this to a writer
     throw new Exception("Illegal attempt to write audio data to a character Writer");
   }
 }
Esempio n. 4
0
 public void append(MaryData md) {
   if (md == null) throw new NullPointerException("Received null marydata");
   if (!md.getType().equals(this.getType()))
     throw new IllegalArgumentException(
         "Cannot append mary data of type `"
             + md.getType().name()
             + "' to mary data of type `"
             + this.getType().name()
             + "'");
   if (getType().isXMLType()) {
     NodeList kids = md.getDocument().getDocumentElement().getChildNodes();
     logger.debug("Appending " + kids.getLength() + " nodes to MaryXML structure");
     Element docEl = this.getDocument().getDocumentElement();
     for (int i = 0; i < kids.getLength(); i++) {
       docEl.appendChild(this.getDocument().importNode(kids.item(i), true));
     }
   } else if (getType().isTextType()) {
     // Attention: XML type is a text type!
     if (this.plainText == null) {
       this.plainText = md.getPlainText();
     } else {
       this.plainText = this.plainText + "\n\n" + md.getPlainText();
     }
   } else if (getType().equals(MaryDataType.get("AUDIO"))) {
     appendAudio(md.getAudio());
   } else {
     throw new UnsupportedOperationException(
         "Cannot append two mary data items of type `" + getType() + "'");
   }
 }
Esempio n. 5
0
 /**
  * Set the content data of this MaryData object from the given String. For XML data ({@link
  * MaryDataType#isXMLType()}), parse the String representation of the data into a DOM tree.
  *
  * @param dataString string representation of the input data.
  * @throws ParserConfigurationException ParserConfigurationException
  * @throws IOException IOException
  * @throws SAXException SAXException
  * @throws IllegalArgumentException if this method is called for MaryDataTypes that are neither
  *     text nor XML.
  */
 public void setData(String dataString)
     throws ParserConfigurationException, SAXException, IOException {
   // First, some data cleanup:
   dataString = StringUtils.purgeNonBreakingSpaces(dataString);
   // Now, deal with it.
   if (type.isXMLType()) {
     logger.debug(
         "Parsing XML input (" + (doValidate ? "" : "non-") + "validating): " + dataString);
     xmlDocument = DomUtils.parseDocument(dataString, doValidate);
   } else if (type.isTextType()) {
     logger.debug("Setting text input: " + dataString);
     plainText = dataString;
   } else {
     throw new IllegalArgumentException("Cannot set data of type " + type + " from a string");
   }
 }
Esempio n. 6
0
 public MaryData(MaryDataType type, Locale locale, boolean createStubDocument) {
   if (type == null) throw new NullPointerException("Received null type for MaryData");
   this.type = type;
   this.locale = locale;
   // The following is the default setting for module output (we suppose
   // that for the input data, setValidating() is called as appropriate):
   doValidate = MaryProperties.getBoolean("maryxml.validate.modules", false);
   if (createStubDocument && type.isMaryXML()) {
     xmlDocument = MaryXML.newDocument();
   }
 }
Esempio n. 7
0
 /**
  * Write our internal representation to output stream <code>os</code>, in the appropriate way as
  * determined by our <code>type</code>.
  *
  * @param os os
  * @throws TransformerConfigurationException TransformerConfigurationException
  * @throws FileNotFoundException FileNotFoundException
  * @throws TransformerException TransformerException
  * @throws IOException IOException
  * @throws Exception Exception
  */
 public void writeTo(OutputStream os)
     throws TransformerConfigurationException, FileNotFoundException, TransformerException,
         IOException, Exception {
   if (type.isXMLType()) {
     if (writer == null) writer = new MaryNormalisedWriter();
     if (logger.getEffectiveLevel().equals(Level.DEBUG)) {
       ByteArrayOutputStream debugOut = new ByteArrayOutputStream();
       writer.output(xmlDocument, debugOut);
       logger.debug(debugOut.toString());
     }
     writer.output(xmlDocument, new BufferedOutputStream(os));
   } else if (type.isTextType()) { // caution: XML types are text types!
     writeTo(new OutputStreamWriter(os, "UTF-8"));
   } else { // audio
     logger.debug("Writing audio output, frame length " + audio.getFrameLength());
     AudioSystem.write(audio, audioFileFormat.getType(), os);
     os.flush();
     os.close();
   }
 }