/** * Deserializes an XCAS from a stream. By default this is not lenient, meaning that if the XCAS * references Types that are not in the Type System, an Exception will be thrown. Use * {@link XCASDeserializer#deserialize(InputStream,CAS,boolean)} to turn on lenient mode and * ignore any unknown types. * * @param aStream * input stream from which to read the XCAS XML document * @param aCAS * CAS into which to deserialize. This CAS must be set up with a type system that is * compatible with that in the XCAS * * @throws SAXException * if an XML Parsing error occurs * @throws IOException * if an I/O failure occurs */ public static void deserialize(InputStream aStream, CAS aCAS) throws SAXException, IOException { XCASDeserializer.deserialize(aStream, aCAS, false); }
/** * Deserializes an XCAS from a stream. * * @param aStream * input stream from which to read the XCAS XML document * @param aCAS * CAS into which to deserialize. This CAS must be set up with a type system that is * compatible with that in the XCAS. * @param aLenient * if true, unknown Types will be ignored. If false, unknown Types will cause an * exception. The default is false. * * @throws SAXException * if an XML Parsing error occurs * @throws IOException * if an I/O failure occurs */ public static void deserialize(InputStream aStream, CAS aCAS, boolean aLenient) throws SAXException, IOException { XMLReader xmlReader = XMLUtils.createXMLReader(); XCASDeserializer deser = new XCASDeserializer(aCAS.getTypeSystem()); ContentHandler handler; if (aLenient) { handler = deser.getXCASHandler(aCAS, new OutOfTypeSystemData()); } else { handler = deser.getXCASHandler(aCAS); } xmlReader.setContentHandler(handler); xmlReader.parse(new InputSource(aStream)); }
XCASDeserializer deser = new XCASDeserializer(myCas.getTypeSystem(), this.uimaContext); deser.setDocumentTypeName("Detag:DetagContent"); if (!ignoreResponse) { handler = deser.getXCASHandler(myCas, outOfTypeSystemData); } else { handler = new DefaultHandler();
/** * Create a default handler for deserializing an XCAS into the <code>cas</code> parameter. * <p> * Warning: for efficiency reasons, the deserializer does not do much type checking for features * and their values. It is expected that the incoming XCAS conforms to the type system provided. * If it doesn't, the results are undefined. * * @param cas * This CAS will be used to hold the data of the serialized XCAS. * @return The <code>DefaultHandler</code> to pass to the SAX parser. */ public DefaultHandler getXCASHandler(CAS cas) { return getXCASHandler(cas, null); }
if (qualifiedName.equals(getDocumentTypeName())) { readDocument(attrs); } else {
public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { if (mDelegateHandler == null) { // try to find out whether we should use the XCAS or XMI deserializers // if there's an xmi:version attribute, always use XMI String xmiVer = attributes.getValue("xmi:version"); if (xmiVer != null && xmiVer.length() > 0) { XmiCasDeserializer deser = new XmiCasDeserializer(mCAS.getTypeSystem()); mDelegateHandler = deser.getXmiCasHandler(mCAS, mLenient); } else if ("CAS".equals(localName)) // use XCAS { XCASDeserializer deser = new XCASDeserializer(mCAS.getTypeSystem()); mDelegateHandler = deser .getXCASHandler(mCAS, mLenient ? new OutOfTypeSystemData() : null); } else // default to XMI { XmiCasDeserializer deser = new XmiCasDeserializer(mCAS.getTypeSystem()); mDelegateHandler = deser.getXmiCasHandler(mCAS, mLenient); } mDelegateHandler.startDocument(); } mDelegateHandler.startElement(uri, localName, qName, attributes); }
@Override public void readFields(DataInput in) throws IOException { int dataLength = in.readInt(); byte[] data = new byte[dataLength]; in.readFully(data); String serializedCAS = new String(data, "UTF-8"); try { XCASDeserializer.deserialize(new ByteArrayInputStream(serializedCAS.getBytes("UTF-8")), cas); } catch (SAXException e) { e.printStackTrace(); } }
generator.setDocumentTextTypeName(this.getDocumentTextTypeName()); generator.setDocumentTextFeatureName(this.getDocumentTextFeatureName()); XCASDeserializer xcasDeser = new XCASDeserializer(aContainer.getTypeSystem()); xcasDeser.setDocumentTypeName(this.getDocumentTextTypeName()); ootsd = new OutOfTypeSystemData(); generator.setContentHandler(xcasDeser.getXCASHandler(aContainer, ootsd)); try { generator.generateXCas(aData);
/** * create a CAS object from the given XCAS and typesystem files. * * @param tsFile - * a typesystem file * @param xcasFile - * a xcas file * @return CAS - CAS object created from the given input data * @throws Exception passthru */ public static CAS getCASfromXCAS(File tsFile, File xcasFile) throws Exception { try { Object tsDescriptor = UIMAFramework.getXMLParser().parse( new XMLInputSource(tsFile)); TypeSystemDescription tsDesc = (TypeSystemDescription) tsDescriptor; CAS cas = CasCreationUtils.createCas(tsDesc, null, new FsIndexDescription[0]); SAXParser parser = XMLUtils.createSAXParserFactory().newSAXParser(); XCASDeserializer xcasDeserializer = new XCASDeserializer(cas .getTypeSystem()); parser.parse(xcasFile, xcasDeserializer.getXCASHandler(cas)); return cas; } catch (Exception ex) { JUnitExtension.handleException(ex); } return null; }
/** * @param aCas * the target CAS * @param aFile * the file to read from * @throws IOException * if there is a problem reading the file * @deprecated Use {@link CasIOUtils#load(java.net.URL, CAS)} instead. */ @Deprecated public static void readXCas(CAS aCas, File aFile) throws IOException { InputStream is = null; try { is = new FileInputStream(aFile); XCASDeserializer.deserialize(is, aCas); } catch (SAXException e) { IOException ioe = new IOException(e.getMessage()); ioe.initCause(e); throw ioe; // NOPMD // If we were using Java 1.6 and add the wrapped exception to the IOException // constructor, we would not get a warning here } finally { closeQuietly(is); } }
/** * create a CAS object from the given XCAS and typesystem files * * @param tsFile - * a typesystem file * @param xcasFile - * a xcas file * * @return CAS - CAS object created from the given input data * @throws Exception passthru */ public static CAS getCASfromXCAS(File tsFile, File xcasFile) throws Exception { try { Object tsDescriptor = UIMAFramework.getXMLParser().parse( new XMLInputSource(tsFile)); TypeSystemDescription tsDesc = (TypeSystemDescription) tsDescriptor; CAS cas = CasCreationUtils.createCas(tsDesc, null, new FsIndexDescription[0]); SAXParser parser = XMLUtils.createSAXParserFactory().newSAXParser(); XCASDeserializer xcasDeserializer = new XCASDeserializer(cas .getTypeSystem()); parser.parse(xcasFile, xcasDeserializer.getXCASHandler(cas)); return cas; } catch (Exception ex) { JUnitExtension.handleException(ex); } return null; }
@Override public void process(JCas jCas) throws AnalysisEngineProcessException { URI uri = ViewUriUtil.getURI(jCas); InputStream inputStream = null; try { inputStream = uri.toURL().openStream(); switch (this.xmlScheme) { case XMI: XmiCasDeserializer.deserialize(inputStream, jCas.getCas()); break; case XCAS: XCASDeserializer.deserialize(inputStream, jCas.getCas()); break; } inputStream.close(); } catch (Exception e) { throw new AnalysisEngineProcessException(e); } }
SAXParserFactory saxParserFactory = XMLUtils.createSAXParserFactory(); SAXParser parser = saxParserFactory.newSAXParser(); XCASDeserializer xcasDeserializer = new XCASDeserializer(this.main.getCas() .getTypeSystem()); this.main.getCas().reset(); parser.parse(xcasFile, xcasDeserializer.getXCASHandler(this.main.getCas())); time.stop(); this.main.handleSofas();
@Override public void process(JCas jCas) throws AnalysisEngineProcessException { URI uri = ViewUriUtil.getURI(jCas); InputStream inputStream = null; try { inputStream = uri.toURL().openStream(); switch (this.xmlScheme) { case XMI: XmiCasDeserializer.deserialize(inputStream, jCas.getCas()); break; case XCAS: XCASDeserializer.deserialize(inputStream, jCas.getCas()); break; } inputStream.close(); } catch (Exception e) { throw new AnalysisEngineProcessException(e); } }
public void getNext(JCas jCas) throws IOException, CollectionException { if (!hasNext()) { throw new RuntimeException("getNext(jCas) was called but hasNext() returns false"); } FileInputStream inputStream = new FileInputStream(currentFile); try { if (xmlScheme.equals(XMI)) XmiCasDeserializer.deserialize(inputStream, jCas.getCas()); else XCASDeserializer.deserialize(inputStream, jCas.getCas()); } catch (SAXException e) { throw new CollectionException(e); } finally { inputStream.close(); } completed++; currentFile = null; }
public void getNext(JCas jCas) throws IOException, CollectionException { if (!hasNext()) { throw new RuntimeException("getNext(jCas) was called but hasNext() returns false"); } FileInputStream inputStream = new FileInputStream(currentFile); try { if (xmlScheme.equals(XMI)) XmiCasDeserializer.deserialize(inputStream, jCas.getCas()); else XCASDeserializer.deserialize(inputStream, jCas.getCas()); } catch (SAXException e) { throw new CollectionException(e); } finally { inputStream.close(); } completed++; currentFile = null; }
XCASDeserializer.deserialize(xCasStream, cas); System.out.println("XCAS deserialized");
XCASDeserializer.deserialize(xCasStream, cas); System.out.println("XCAS deserialized");
@Override public void map(Text key, Text value, OutputCollector<Text, CASWritable> output, Reporter reporter) throws IOException { try { CAS cas = CasCreationUtils.createCas(createTypeSystemDescription(), null, null); XCASDeserializer.deserialize(new StringInputStream(value.toString()), cas); // XCASDeserializer.deserialize(IOUtils.toInputStream(value.toString(), "utf8"), cas); CASWritable casWritable = new BinCasWithTypeSystemWritable(); casWritable.setCAS(cas); output.collect(key, casWritable); reporter.incrCounter("hpz", "processed cas", 1); if (cas.getDocumentText() == null) reporter.incrCounter("hpz", "document text null", 1); else reporter.incrCounter("hpz", "doc size", cas.getDocumentText().length()); } catch (Exception e) { reporter.incrCounter("hpz", "exception " + e.getMessage(), 1); e.printStackTrace(System.err); } }
XCASDeserializer.deserialize(fis, aCAS, lenient);