org.apache.uima.cas.impl.XmiCasSerializer Java Examples

private static void serialize(JCas jcas, File file) throws SAXException, IOException {
  OutputStream outputStream = null;
  try {
    outputStream = new BufferedOutputStream(new FileOutputStream(file));

    XmiCasSerializer xmiSerializer = new XmiCasSerializer(
        jcas.getTypeSystem());
    XMLSerializer xmlSerializer = new XMLSerializer(outputStream, true);
    xmiSerializer.serialize(jcas.getCas(),
        xmlSerializer.getContentHandler());

  } catch (FileNotFoundException fnfe) {
    throw new FileNotFoundException(fnfe.getMessage());
  } catch (SAXException saxe) {
    throw new SAXException(saxe.getMessage());
  } finally {
    try {
      outputStream.close();
    } catch (IOException ioe) {
      throw new IOException(ioe.getMessage());
    }
  }
}
 

private String serialize() throws Exception {    
  StringWriter sw = null;
  ByteArrayOutputStream baos = null;
  try {
    if (doJson) {
      sw = new StringWriter();
      jcs.serialize(cas, sw);
      return sw.toString();
    } else {
      XmiCasSerializer xcs = new XmiCasSerializer(jcs.getCss().getFilterTypes());
      baos = new ByteArrayOutputStream();
      
      XMLSerializer sax2xml = new XMLSerializer(baos, jcs.getCss().isFormattedOutput);
      xcs.serialize(cas, sax2xml.getContentHandler(), null);
      return baos.toString("UTF-8");
    }
  } catch (Exception e) {
    System.err.format("Exception occurred. The string produced so far was: %n%s%n",
        (sw == null) ? baos.toString("UTF-8") : sw.toString());
    throw e;
  }
}
 

private String serializeCas(CAS aCas) throws RecommendationException
{
    try (StringWriter out = new StringWriter()) {
        // Passing "null" as the type system to the XmiCasSerializer means that we want 
        // to serialize all types (i.e. no filtering for a specific target type system).
        XmiCasSerializer xmiCasSerializer = new XmiCasSerializer(null);
        XMLSerializer sax2xml = new XMLSerializer(out, true);
        xmiCasSerializer.serialize(getRealCas(aCas), sax2xml.getContentHandler(), null, null,
                null);
        return out.toString();
    }
    catch (CASRuntimeException | SAXException | IOException e) {
        throw new RecommendationException("Error while serializing CAS!", e);
    }
}
 

private String buildPredictionResponse(CAS aCas) throws SAXException, IOException
{
    try (ByteArrayOutputStream out = new ByteArrayOutputStream()) {
        XmiCasSerializer.serialize(aCas, null, out, true, null);
        PredictionResponse response = new PredictionResponse();
        response.setDocument(new String(out.toByteArray(), UTF_8));
        ObjectMapper mapper = new ObjectMapper();
        return mapper.writeValueAsString(response);
    }
}
 

@Override
public void process(JCas aJCas)
        throws AnalysisEngineProcessException
{
    try {
        java.io.ByteArrayOutputStream jCasOutputStream = new java.io.ByteArrayOutputStream();
        XmiCasSerializer.serialize(aJCas.getCas(), jCasOutputStream);

        // get name = id + .xmi
        String singleEntryName = DocumentMetaData.get(aJCas).getDocumentId() + ".xmi";
        // convert output stream to input stream
        //            InputStream inputStream = new ByteArrayInputStream(jCasOutputStream.toByteArray());

        // add to the tar
        addSingleEntryToTar(jCasOutputStream.toByteArray(), singleEntryName);

        if (!typeSystemWritten) {
            writeTypeSystem(aJCas);
            typeSystemWritten = true;
        }

        counter++;
    }
    catch (IOException | SAXException ex) {
        throw new AnalysisEngineProcessException(ex);
    }
}
 

public void setJCas(JCas jCas)
        throws IOException
{
    // now convert to XMI
    ByteArrayOutputStream byteOutputStream = new ByteArrayOutputStream();
    try {
        XmiCasSerializer.serialize(jCas.getCas(), byteOutputStream);
    }
    catch (SAXException e) {
        throw new IOException(e);
    }

    // encode to base64
    this.base64JCas = new BASE64Encoder().encode(byteOutputStream.toByteArray());
}
 

public JCas toXMICas(JCas cas, Path filePath) {
	try {
		logger.debug("Exporting CAS to {}", filePath);
		XmiCasSerializer.serialize(cas.getCas(), new FileOutputStream(makeParentDirs(filePath).toFile()));
		logger.debug("XMI CAS export succeeded");
		return cas;
	} catch (FileNotFoundException | SAXException e) {
		throw new TermSuiteException(e);
	}
}
 

public static void main(String[] args) throws UIMAException, SAXException, IOException {
  TokenBuilder<Token, Sentence> tokenBuilder = new TokenBuilder<Token, Sentence>(Token.class,
          Sentence.class, "pos", "stem");
  JCas jCas = JCasFactory.createJCas();
  String text = "Me and all my friends are non-conformists.";
  tokenBuilder.buildTokens(jCas, text, "Me and all my friends are non - conformists .",
          "M A A M F A N - C .", "me and all my friend are non - conformist .");

  FileOutputStream out = new FileOutputStream("src/test/resources/data/docs/test.xmi");
  XmiCasSerializer ser = new XmiCasSerializer(jCas.getTypeSystem());
  XMLSerializer xmlSer = new XMLSerializer(out, false);
  ser.serialize(jCas.getCas(), xmlSer.getContentHandler());
  out.close();

}
 

public void testXmiSerialization() throws Exception {

    // create FS
    createExampleFS(cas);

    // serialize

    StringWriter sw = new StringWriter();
    XMLSerializer xmlSer = new XMLSerializer(sw, false);
    XmiCasSerializer xmiSer = new XmiCasSerializer(cas.getTypeSystem());
    xmiSer.serialize(cas, xmlSer.getContentHandler());
    String xml = sw.getBuffer().toString();
    // System.out.println(xml);
    // reset
    cas.reset();

    // deserialize
    XmiCasDeserializer deser = new XmiCasDeserializer(cas.getTypeSystem());
    ContentHandler deserHandler = deser.getXmiCasHandler(cas);
    SAXParserFactory fact = SAXParserFactory.newInstance();
    SAXParser parser = fact.newSAXParser();
    XMLReader xmlReader = parser.getXMLReader();
    xmlReader.setContentHandler(deserHandler);
    xmlReader.parse(new InputSource(new StringReader(xml)));

    // check values
    validateFSData(cas);

  }
 

/**
 * Uima namespace 2 namespace uri.
 *
 * @param uimaNamespace the uima namespace
 * @return the string
 */
private static String uimaNamespace2NamespaceUri(String uimaNamespace) {
  if (uimaNamespace == null || uimaNamespace.length() == 0) {
    return XmiCasSerializer.DEFAULT_NAMESPACE_URI;
  }
  // Our convention is that the Namespace URI is "http:///", followed by the UIMA namespace, with
  // dots converted to slashes, and with ".ecore" appended. (This is EMF's convention for
  // constructing a namespace URI from a Java package name.)
  return "http:///" + uimaNamespace.replace('.', '/') + ".ecore";
}
 

/**
  * Namespace uri 2 uima namespace.
  *
  * @param nsUri the ns uri
  * @return the string
  * @throws URISyntaxException the URI syntax exception
  */
 private static String namespaceUri2UimaNamespace(String nsUri) throws URISyntaxException {
   // Check for the special "no namespace URI", which maps to the null UIMA namespace
   if (XmiCasSerializer.DEFAULT_NAMESPACE_URI.equals(nsUri)) {
     return null;
   }
   // Our convention is that the UIMA namespace is the URI path, with leading slashes
   // removed, trailing ".ecore" removed, and internal slashes converted to dots
   java.net.URI uri = new java.net.URI(nsUri);
   String uimaNs = uri.getPath();
   if (uimaNs == null) {
     // The URI is a URN
     uimaNs = uri.getSchemeSpecificPart();
     uimaNs = uimaNs.replace(':', '.');
   } else {
     // The URI is a URL
     while (uimaNs.startsWith("/")) {
uimaNs = uimaNs.substring(1);
     }
     if (uimaNs.endsWith(".ecore")) {
uimaNs = uimaNs.substring(0, uimaNs.length() - 6);
     }
     uimaNs = uimaNs.replace('/', '.');
   }
   uimaNs = uimaNs.replace('-', '_');
   return uimaNs;
 }
 

/**
 * Serialize a CAS to a file in XMI format
 * 
 * @param aCas
 *          CAS to serialize
 * @param name
 *          output file
 * @throws SAXException -
 * @throws Exception -
 * 
 * @throws ResourceProcessException -
 */
private void writeXmi(CAS aCas, File name, String modelFileName) throws IOException, SAXException {

  try (FileOutputStream out = new FileOutputStream(name)) {
    // write XMI
    XmiCasSerializer ser = new XmiCasSerializer(aCas.getTypeSystem());
    XMLSerializer xmlSer = new XMLSerializer(out, false);
    ser.serialize(aCas, xmlSer.getContentHandler());
  }
}
 

/**
 * Serialize a CAS to a file in XMI format
 * 
 * @param aCas
 *          CAS to serialize
 * @param name
 *          output file
 * @throws SAXException -
 * @throws Exception -
 * 
 * @throws ResourceProcessException -
 */
private void writeXmi(CAS aCas, File name, String modelFileName) throws IOException, SAXException {

  try (OutputStream out = new FileOutputStream(name)) {
    // write XMI
    XmiCasSerializer ser = new XmiCasSerializer(aCas.getTypeSystem());
    XMLSerializer xmlSer = new XMLSerializer(out, false);
    ser.serialize(aCas, xmlSer.getContentHandler());
  }
}
 

/**
 * Serializes a CAS to XMI format and writes it to an output stream.
 * 
 * @param aCAS
 *          CAS to serialize.
 * @param aStream
 *          output stream to which to write the XMI document
 * 
 * @throws SAXException
 *           if a problem occurs during XMI serialization
 * @throws IOException
 *           if an I/O failure occurs
 */
public static void serialize(CAS aCAS, OutputStream aStream) throws SAXException, IOException {
  XmiCasSerializer.serialize(aCAS, aStream);
}
 

/**
 * Serializes a CAS to XMI format and writes it to an output stream. Allows a TypeSystem to be
 * specified, to which the produced XMI will conform. Any types or features not in the target type
 * system will not be serialized.
 * 
 * @param aCAS
 *          CAS to serialize.
 * @param aTargetTypeSystem
 *          type system to which the produced XMI will conform. Any types or features not in the
 *          target type system will not be serialized.
 *          
 * @param aStream
 *          output stream to which to write the XMI document
 * 
 * @throws SAXException
 *           if a problem occurs during XMI serialization
 * @throws IOException
 *           if an I/O failure occurs
 */
public static void serialize(CAS aCAS, TypeSystem aTargetTypeSystem, OutputStream aStream)
        throws SAXException, IOException {
  XmiCasSerializer.serialize(aCAS, aTargetTypeSystem, aStream);
}