instead of ReportUtil.loadConvertedReport(xml)
194306
private void convertReports() throws RepositoryException {
		
		String statement = 
				"/jcr:root" + ISO9075.encodePath(StorageConstants.REPORTS_ROOT) + 
				"//*[@className='ro.nextreports.server.domain.Report' and @type='Next']" + 
				"//*[fn:name()='jcr:content' and @jcr:mimeType='text/xml']";
		  
		QueryResult queryResult = getTemplate().query(statement);

		NodeIterator nodes = queryResult.getNodes();
		LOG.info("Converter 5.1 : Found " + nodes.getSize() + " report nodes");
		while (nodes.hasNext()) {
			
			Node node = nodes.nextNode();
			
			Node reportNode = node.getParent().getParent().getParent().getParent();
			String reportName = reportNode.getName();
			String reportPath = reportNode.getPath();	
			LOG.info(" * Start convert '" + reportPath + "'");						
												
			Property prop = node.getProperty("jcr:data");			
        	String xml = null;
            try {                  	
            	xml = new Converter_5_2().convertFromInputStream(prop.getBinary().getStream(), true);            	            	
            	if (xml != null) {
                	ValueFactory valueFactory = node.getSession().getValueFactory(); 
                	Binary binaryValue = valueFactory.createBinary(new ByteArrayInputStream(xml.getBytes("UTF-8")));
                	node.setProperty ("jcr:data", binaryValue);                	
                	LOG.info("\t -> OK");
                } else {
                	LOG.error("\t -> FAILED : null xml");
                }
            	            	            	
            } catch (Throwable t) {                    	            	            
            	LOG.error("\t-> FAILED : " + t.getMessage(), t);            	
            } 					
            
		}
	}
199008
public static XmlReport parse( File file ) throws Exception
	{
		Reader in = BOMUtil.newReader( file );

		try
		{
			return parse( in );
		}
		finally
		{
			IOUtil.closeQuietly( in );
		}
	}
1348399
private EREFiller toFiller(final Element xml, final String docid) {
    final String id = generateID(XMLUtils.requiredAttribute(xml, "id"), docid);
    final String type = XMLUtils.requiredAttribute(xml, "type");
    final int extentStart = XMLUtils.requiredIntegerAttribute(xml, "offset");
    final int extentEnd = extentStart + XMLUtils.requiredIntegerAttribute(xml, "length") - 1;
    final String text = xml.getTextContent();

    final ERESpan span = ERESpan.from(extentStart, extentEnd, text);

    final EREFiller ereFiller;
    if (xml.hasAttribute(NORMALIZED_TIME_ATTR)) {
     ereFiller = EREFiller.fromTime(id, type, xml.getAttribute(NORMALIZED_TIME_ATTR), span);
    } else {
      ereFiller = EREFiller.from(id, type, span);
    }
    idMap.put(id, ereFiller);
    return ereFiller;
  }
774224
static function &loadExistingReport($reportfile, $projects_folder = "projects")
    {
        $q = new Reportico();
        $q->reports_path = $projects_folder . "/" . ReporticoApp::getconfig("project");
        $q->projects_folder = $projects_folder;

        $reader = new XmlReader ($q, $reportfile, false);
        $reader->xml2query();

        return $q;
    }
142485
public void loadXml(String fileName) throws CoreException {
        if (fileName == null) {
            return;
        }
        st = new StopTimer();

        // clear markers
        clearMarkers(null);

        final Project findBugsProject = new Project();
        final Reporter bugReporter = new Reporter(javaProject, findBugsProject, monitor);
        bugReporter.setPriorityThreshold(userPrefs.getUserDetectorThreshold());

        reportFromXml(fileName, findBugsProject, bugReporter);
        // Merge new results into existing results.
        updateBugCollection(findBugsProject, bugReporter, false);
        monitor.done();
    }
905366
protected boolean loadReport(ReportsConfig result, InputStream report, String reportName) {
        ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
        ReportConfig reportConfig = null;
        try {
            reportConfig = mapper.readValue(report, ReportConfig.class);
        } catch (IOException e) {
            e.printStackTrace();
            errors.add("Error parsing " + reportName + " " + e.getMessage());
            return false;
        }
        reportConfig.setReportId(reportName);
        result.getReports().put(reportName, reportConfig);
        return true;
    }
1319562
private static Document parseXmlToDocument(final File xmlFile) {
        Document result = null;
        Reader reader = null;
        try {
            reader = new FileReader(xmlFile);
            result = parseXmlStream(reader);
        } catch (FileNotFoundException e) {
            // This should never happen...
        } finally {
            IOUtil.close(reader);
        }

        return result;
    }
1265224
private void run(XmlOperation operation) throws ReportException {
        try {
            operation.run();
        } catch (XMLStreamException | IOException e) {
            throw new ReportException("Cannot write to XML report.", e);
        }
    }
145004
public static String mapXMLToObject(String xml) {
		for (int i = 0; i < keyWordMapping.length; i++) {
			if (keyWordMapping[i][0].equalsIgnoreCase(xml)) {
				return keyWordMapping[i][1];
			}
		}
		return xml;
	}
416677
private final void _xmlWriteRawOn(FormattedWriter writer, boolean callBackToItem) throws IOException
    {
        new RawDataDumper(_persistentMessageStore, writer, callBackToItem).dump();
    }
981767
public static String xmlToString(Document document) throws Exception {
        if (transformer == null) {
            throw new Exception("Transformer is null");
        }
        Source xmlSource = new DOMSource(document);
        StringWriter stringWriter = new StringWriter();
        Result result = new StreamResult(stringWriter);
        transformer.transform(xmlSource, result);
        return stringWriter.toString();
    }
583200
function XMLLoader(loadItem) {
		this.AbstractLoader_constructor(loadItem, true, createjs.Types.XML);

		// public properties
		this.resultFormatter = this._formatResult;
	}
1024916
public Object unmarshalRootElement(Reader inStream, BaseXmlTrxMessageIn soapTrxMessage) throws Exception
    {
    	String xml = Utility.transferURLStream(null, null, inStream, null);
    	soapTrxMessage.getMessage().setXML(xml);

    	return xml;
    }
424278
public static void convertDOMToXML(Node doc, Writer out)
    {
        try {
            // Use a Transformer for output
            TransformerFactory tFactory = TransformerFactory.newInstance();
            Transformer transformer = tFactory.newTransformer();

            DOMSource source = new DOMSource(doc);

            StreamResult result = new StreamResult(out);
            transformer.transform(source, result);
        } catch (TransformerConfigurationException tce) {
            // Error generated by the parser
            tce.printStackTrace();
        } catch (TransformerException te) {
            // Error generated by the parser
            te.printStackTrace();
        }
    }
93575
private static Document _loadDocument(InputStream is) throws SAXException, IOException {
	InputSource source = new InputSource(is);

	return XMLUtil.parse(source, null, false);
    }
18526
public static void objectToXML(Object object, String fileName) throws FileNotFoundException {
		FileOutputStream fo = new FileOutputStream(fileName);
		XMLEncoder encoder = new XMLEncoder(fo);
		encoder.writeObject(object);
		encoder.close();
	}
39593
def to_xml(self):
        """"""
        changesXML = ""
        for change in self.changes:
            changeParams = {"action": change[0], "record": change[1].to_xml()}
            changesXML += self.ChangeXML % changeParams
        params = {"comment": self.comment, "changes": changesXML}
        return self.ChangeResourceRecordSetsBody % params