import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
/**
 * Write the passed map to the passed output stream using the predefined XML
 * layout.
 *
 * @param aMap
 *        The map to be written. May not be <code>null</code>.
 * @param aOS
 *        The output stream to write to. The stream is closed independent of
 *        success or failure. May not be <code>null</code>.
 * @return {@link ESuccess#SUCCESS} when everything went well,
 *         {@link ESuccess#FAILURE} otherwise.
 */
@Nonnull
public static ESuccess writeMap (@Nonnull final Map <String, String> aMap, @Nonnull @WillClose final OutputStream aOS)
{
  ValueEnforcer.notNull (aMap, "Map");
  ValueEnforcer.notNull (aOS, "OutputStream");

  try
  {
    final IMicroDocument aDoc = createMapDocument (aMap);
    return MicroWriter.writeToStream (aDoc, aOS, XMLWriterSettings.DEFAULT_XML_SETTINGS);
  }
  finally
  {
    StreamHelper.close (aOS);
  }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
/**
 * Write the passed collection to the passed output stream using the
 * predefined XML layout.
 *
 * @param aCollection
 *        The map to be written. May not be <code>null</code>.
 * @param aOS
 *        The output stream to write to. The stream is closed independent of
 *        success or failure. May not be <code>null</code>.
 * @return {@link ESuccess#SUCCESS} when everything went well,
 *         {@link ESuccess#FAILURE} otherwise.
 */
@Nonnull
public static ESuccess writeList (@Nonnull final Collection <String> aCollection,
                                  @Nonnull @WillClose final OutputStream aOS)
{
  ValueEnforcer.notNull (aCollection, "Collection");
  ValueEnforcer.notNull (aOS, "OutputStream");

  try
  {
    final IMicroDocument aDoc = createListDocument (aCollection);
    return MicroWriter.writeToStream (aDoc, aOS, XMLWriterSettings.DEFAULT_XML_SETTINGS);
  }
  finally
  {
    StreamHelper.close (aOS);
  }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
private static void _testGetNodeAsXHTMLString (final IMicroNode aNode)
{
  // try all permutations
  final XMLWriterSettings aSettings = XMLWriterSettings.createForXHTML ();
  for (int nCharSet = 0; nCharSet < 2; ++nCharSet)
  {
    aSettings.setCharset (nCharSet == 1 ? StandardCharsets.ISO_8859_1 : StandardCharsets.UTF_8);
    for (final EXMLSerializeIndent eIndent : EXMLSerializeIndent.values ())
    {
      aSettings.setIndent (eIndent);
      for (final EXMLSerializeDocType eDocType : EXMLSerializeDocType.values ())
      {
        aSettings.setSerializeDocType (eDocType);
        assertNotNull (MicroWriter.getNodeAsString (aNode, aSettings));
      }
    }
  }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
private static void _testGetNodeAsXMLString (final IMicroNode aNode)
{
  // try all permutations
  final XMLWriterSettings aSettings = new XMLWriterSettings ();
  for (int nCharSet = 0; nCharSet < 2; ++nCharSet)
  {
    aSettings.setCharset (nCharSet == 1 ? StandardCharsets.ISO_8859_1 : StandardCharsets.UTF_8);
    for (final EXMLSerializeIndent eIndent : EXMLSerializeIndent.values ())
    {
      aSettings.setIndent (eIndent);
      for (final EXMLSerializeDocType eDocType : EXMLSerializeDocType.values ())
      {
        aSettings.setSerializeDocType (eDocType);
        assertNotNull (MicroWriter.getNodeAsString (aNode, aSettings));
      }
    }
  }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
@Ignore ("Takes too long and was already tested with JDK 1.8 runtime parser")
public void testSpecialCharactersXML10Text ()
{
  final EXMLSerializeVersion eXMLSerializeVersion = EXMLSerializeVersion.XML_10;

  final XMLWriterSettings aSettings = new XMLWriterSettings ().setSerializeVersion (eXMLSerializeVersion);
  for (int i = Character.MIN_VALUE; i <= Character.MAX_VALUE; ++i)
    if (!XMLCharHelper.isInvalidXMLTextChar (eXMLSerializeVersion, (char) i))
    {
      final String sText = "abc" + (char) i + "def";
      assertEquals (7, sText.length ());
      final IMicroDocument aDoc = new MicroDocument ();
      aDoc.appendElement ("root").appendText (sText);
      final String sXML = MicroWriter.getNodeAsString (aDoc, aSettings);
      final IMicroDocument aDoc2 = MicroReader.readMicroXML (sXML);
      assertNotNull ("Failed to read with byte " + i + "\n" + sXML, aDoc2);
      assertEquals ("Length for byte " + i, i == 0 ? 6 : 7, aDoc2.getDocumentElement ().getTextContent ().length ());
      assertTrue ("Difference in byte 0x" + Integer.toHexString (i), aDoc.isEqualContent (aDoc2));
    }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
public void testSpecialXMLAttrs ()
{
  final String s = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                   "<root xml:lang=\"en\" xml:space=\"preserve\" xml:base=\"baseuri\" xml:id=\"4711\">" +
                   "Bla" +
                   "</root>";
  final IMicroDocument aDoc = MicroReader.readMicroXML (s);
  assertNotNull (aDoc);
  final IMicroElement eRoot = aDoc.getDocumentElement ();
  assertEquals ("en", eRoot.getAttributeValue (XMLConstants.XML_NS_URI, "lang"));
  assertNull (eRoot.getAttributeValue ("lang"));
  assertEquals ("preserve", eRoot.getAttributeValue (XMLConstants.XML_NS_URI, "space"));
  assertEquals ("baseuri", eRoot.getAttributeValue (XMLConstants.XML_NS_URI, "base"));
  assertEquals ("4711", eRoot.getAttributeValue (XMLConstants.XML_NS_URI, "id"));

  // Ensure they are written as well
  assertEquals (s, MicroWriter.getNodeAsString (aDoc, new XMLWriterSettings ().setIndent (EXMLSerializeIndent.NONE)));
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
public static void validateAndProduceSVRL (@Nonnull final File aSchematron, final File aXML) throws Exception
{
  final PSSchema aSchema = new PSReader (new FileSystemResource (aSchematron)).readSchema ();
  final PSPreprocessor aPreprocessor = new PSPreprocessor (PSXPathQueryBinding.getInstance ());
  final PSSchema aPreprocessedSchema = aPreprocessor.getAsPreprocessedSchema (aSchema);
  final String sSCH = new PSWriter (new PSWriterSettings ().setXMLWriterSettings (new XMLWriterSettings ())).getXMLString (aPreprocessedSchema);

  if (false)
    System.out.println (sSCH);

  final SchematronResourceSCH aSCH = new SchematronResourceSCH (new ReadableResourceString (sSCH,
                                                                                            StandardCharsets.UTF_8));

  // Perform validation
  final SchematronOutputType aSVRL = aSCH.applySchematronValidationToSVRL (new FileSystemResource (aXML));
  assertNotNull (aSVRL);
  if (false)
    System.out.println (new SVRLMarshaller ().getAsString (aSVRL));
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
public static void main (final String [] args)
{
  final File aSchFile = new File ("../../../schematron/EN16931-EDIFACT-validation.sch");
  final File aXsltFile = new File ("../../../stylesheet/EN16931-EDIFACT-validation-compiled.xsl");

  logger.info ("Reading Schematron");
  final SchematronResourceSCH aSch = SchematronResourceSCH.fromFile (aSchFile);
  final ISchematronXSLTBasedProvider aXsltProvider = aSch.getXSLTProvider ();

  // Write the resulting XSLT file to disk
  final MapBasedNamespaceContext aNSContext = new MapBasedNamespaceContext ().addMapping ("svrl",
                                                                                          CSVRL.SVRL_NAMESPACE_URI);
  // Add all namespaces from XSLT document root
  final String sNSPrefix = XMLConstants.XMLNS_ATTRIBUTE + ":";
  XMLHelper.getAllAttributesAsMap (aXsltProvider.getXSLTDocument ().getDocumentElement ())
           .forEach ( (sAttrName, sAttrValue) -> {
             if (sAttrName.startsWith (sNSPrefix))
               aNSContext.addMapping (sAttrName.substring (sNSPrefix.length ()), sAttrValue);
           });

  final XMLWriterSettings aXWS = new XMLWriterSettings ();
  aXWS.setNamespaceContext (aNSContext).setPutNamespaceContextPrefixesInRoot (true);

  logger.info ("Writing XSLT");
  final OutputStream aOS = FileHelper.getOutputStream (aXsltFile);
  XMLWriter.writeToStream (aXsltProvider.getXSLTDocument (), aOS, aXWS);

  logger.info ("Done");
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
/**
 * @return The XML writer settings to be used based on this writer settings.
 *         Never <code>null</code>.
 */
@Nonnull
default IXMLWriterSettings getXMLWriterSettings ()
{
  final XMLWriterSettings ret = new XMLWriterSettings ().setNamespaceContext (getNamespaceContext ())
                                                        .setIndent (isFormattedOutput () ? EXMLSerializeIndent.INDENT_AND_ALIGN
                                                                                         : EXMLSerializeIndent.NONE);
  if (hasIndentString ())
    ret.setIndentationString (getIndentString ());
  if (hasCharset ())
    ret.setCharset (getCharset ());
  return ret.setNewLineMode (ENewLineMode.DEFAULT)
            .setIncorrectCharacterHandling (EXMLIncorrectCharacterHandling.DO_NOT_WRITE_LOG_WARNING);
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
public void testWrite () throws SAXException
{
  // 1. read a valid one
  final ChangeLog aCL = ChangeLogSerializer.readChangeLog (new ClassPathResource (CChangeLog.CHANGELOG_XML_FILENAME));
  assertNotNull (aCL);

  // 2. write it
  final IMicroDocument aDoc = ChangeLogSerializer.writeChangeLog (aCL);
  assertNotNull (aDoc);

  // 3. read again -> must be equal
  final ChangeLog aCL2 = ChangeLogSerializer.readChangeLog (new MicroDOMInputStreamProvider (aDoc,
                                                                                             XMLWriterSettings.DEFAULT_XML_CHARSET_OBJ));
  assertNotNull (aCL2);

  // 4. read again with XML Schema
  final Document aW3CDoc = DOMReader.readXMLDOM (new ReadableResourceSAXInputSource (new MicroDOMInputStreamProvider (aDoc,
                                                                                                                      XMLWriterSettings.DEFAULT_XML_CHARSET_OBJ),
                                                                                     null),
                                                 new DOMReaderSettings ().setSchema (XMLSchemaCache.getInstance ()
                                                                                                   .getSchema (new ClassPathResource (CChangeLog.CHANGELOG_XSD_10))));
  assertNotNull (aW3CDoc);

  CommonsTestHelper.testDefaultImplementationWithEqualContentObject (aCL, aCL2);

  try
  {
    ChangeLogSerializer.writeChangeLog (null);
    fail ();
  }
  catch (final NullPointerException ex)
  {}
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
public void testXMLVersion ()
{
  for (final EXMLSerializeVersion eVersion : EXMLSerializeVersion.values ())
  {
    final IMicroDocument aDoc = MicroReader.readMicroXML (TEST_XML);
    final XMLWriterSettings aSettings = new XMLWriterSettings ();
    aSettings.setSerializeVersion (eVersion);
    final String sXML = MicroWriter.getNodeAsString (aDoc, aSettings);
    assertNotNull (sXML);
    assertTrue (sXML.contains ("version=\"" +
                               eVersion.getXMLVersionOrDefault (EXMLVersion.XML_10).getVersion () +
                               "\""));
  }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
@Ignore ("Takes too long and was already tested with JDK 1.8 runtime parser")
public void testSpecialCharactersXML10CDATA ()
{
  final EXMLSerializeVersion eXMLSerializeVersion = EXMLSerializeVersion.XML_10;

  final XMLWriterSettings aSettings = new XMLWriterSettings ().setSerializeVersion (eXMLSerializeVersion);
  for (int i = Character.MIN_VALUE; i <= Character.MAX_VALUE; ++i)
    if (!XMLCharHelper.isInvalidXMLCDATAChar (eXMLSerializeVersion, (char) i))
    {
      final String sText = "abc" + (char) i + "def";
      assertEquals (7, sText.length ());
      final IMicroDocument aDoc = new MicroDocument ();
      aDoc.appendElement ("root").appendCDATA (sText);
      final String sXML = MicroWriter.getNodeAsString (aDoc, aSettings);
      final IMicroDocument aDoc2 = MicroReader.readMicroXML (sXML);
      assertNotNull ("Failed to read with byte " + i + "\n" + sXML, aDoc2);
      assertEquals ("Length for byte " + i, i == 0 ? 6 : 7, aDoc2.getDocumentElement ().getTextContent ().length ());

      // Difference between created "\r" and read "\n"
      if (i != '\r')
        if (!aDoc.isEqualContent (aDoc2))
        {
          final String sXML2 = MicroWriter.getNodeAsString (aDoc2, aSettings);
          fail ("0x" + Integer.toHexString (i) + "\n" + sXML + "\n" + sXML2);
        }
    }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
@Ignore ("Takes too long and was already tested with JDK 1.8 runtime parser")
public void testSpecialCharactersXML11Text ()
{
  final EXMLSerializeVersion eXMLSerializeVersion = EXMLSerializeVersion.XML_11;

  final XMLWriterSettings aSettings = new XMLWriterSettings ().setSerializeVersion (eXMLSerializeVersion);
  for (int i = Character.MIN_VALUE; i <= Character.MAX_VALUE; ++i)
    if (!XMLCharHelper.isInvalidXMLTextChar (eXMLSerializeVersion, (char) i))
    {
      final String sText = "abc" + (char) i + "def";
      assertEquals (7, sText.length ());
      final IMicroDocument aDoc = new MicroDocument ();
      aDoc.appendElement ("root").appendText (sText);
      final String sXML = MicroWriter.getNodeAsString (aDoc, aSettings);
      final IMicroDocument aDoc2 = MicroReader.readMicroXML (sXML);
      assertNotNull ("Failed to read with byte " + i + "\n" + sXML, aDoc2);
      assertEquals ("Length for byte " + i, i == 0 ? 6 : 7, aDoc2.getDocumentElement ().getTextContent ().length ());

      // Difference between created "0x2028" and read "\n"
      if (i != 0x2028)
        if (!aDoc.isEqualContent (aDoc2))
        {
          final String sXML2 = MicroWriter.getNodeAsString (aDoc2, aSettings);
          fail ("0x" + Integer.toHexString (i) + "\n" + sXML + "\n" + sXML2);
        }
    }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
@Ignore ("Takes too long and was already tested with JDK 1.8 runtime parser")
public void testSpecialCharactersXML11CDATA ()
{
  final EXMLSerializeVersion eXMLSerializeVersion = EXMLSerializeVersion.XML_11;

  final XMLWriterSettings aSettings = new XMLWriterSettings ().setSerializeVersion (eXMLSerializeVersion);
  for (int i = Character.MIN_VALUE; i <= Character.MAX_VALUE; ++i)
    if (!XMLCharHelper.isInvalidXMLCDATAChar (eXMLSerializeVersion, (char) i))
    {
      final String sText = "abc" + (char) i + "def";
      assertEquals (7, sText.length ());
      final IMicroDocument aDoc = new MicroDocument ();
      aDoc.appendElement ("root").appendCDATA (sText);
      final String sXML = MicroWriter.getNodeAsString (aDoc, aSettings);
      final IMicroDocument aDoc2 = MicroReader.readMicroXML (sXML);
      assertNotNull ("Failed to read with byte " + i + "\n" + sXML, aDoc2);
      assertEquals ("Length for byte " + i, i == 0 ? 6 : 7, aDoc2.getDocumentElement ().getTextContent ().length ());

      // Difference between created "\r" and read "\n"
      // Difference between created "0x2028" and read "\n"
      if (i != '\r' && i != 0x2028)
        if (!aDoc.isEqualContent (aDoc2))
        {
          final String sXML2 = MicroWriter.getNodeAsString (aDoc2, aSettings);
          fail ("0x" + Integer.toHexString (i) + "\n" + sXML + "\n" + sXML2);
        }
    }
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
/**
 * Test: use namespaces all over the place and mix them quite complex
 */
@Test
public void testNamespaces ()
{
  final XMLWriterSettings xs = new XMLWriterSettings ();
  xs.setIndent (EXMLSerializeIndent.NONE);

  final String s = "<?xml version=\"1.0\"?>" +
                   "<verrryoot>" +
                   "<root xmlns=\"myuri\" xmlns:a='foo'>" +
                   "<child xmlns=\"\">" +
                   "<a:child2>Value text - no entities!</a:child2>" +
                   "</child>" +
                   "</root>" +
                   "</verrryoot>";
  final IMicroDocument aDoc = MicroReader.readMicroXML (s);
  assertNotNull (aDoc);

  final NonBlockingByteArrayOutputStream baos = new NonBlockingByteArrayOutputStream ();
  new MicroSerializer (xs).write (aDoc, baos);
  final String sXML = baos.getAsString (StandardCharsets.UTF_8);
  assertEquals ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                "<verrryoot>" +
                "<root xmlns=\"myuri\">" +
                "<ns0:child xmlns:ns0=\"\">" +
                "<ns1:child2 xmlns:ns1=\"foo\">Value text - no entities!</ns1:child2>" +
                "</ns0:child>" +
                "</root>" +
                "</verrryoot>",
                sXML);
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
/**
 * Test: Use 2 different namespaces and use them both more than once
 */
@Test
public void testNamespaces2 ()
{
  final XMLWriterSettings xs = new XMLWriterSettings ();
  xs.setIndent (EXMLSerializeIndent.NONE);

  final String s = "<?xml version=\"1.0\"?>" +
                   "<verrryoot xmlns='uri1'>" +
                   "<root>" +
                   "<child xmlns='uri2'>" +
                   "<child2>Value text - no entities!</child2>" +
                   "</child>" +
                   "</root>" +
                   "</verrryoot>";
  final IMicroDocument aDoc = MicroReader.readMicroXML (s);
  assertNotNull (aDoc);

  final NonBlockingByteArrayOutputStream baos = new NonBlockingByteArrayOutputStream ();
  new MicroSerializer (xs).write (aDoc, baos);
  final String sXML = baos.getAsString (StandardCharsets.UTF_8);
  assertEquals ("<?xml version=\"1.0\" encoding=\"UTF-8\"?>" +
                "<verrryoot xmlns=\"uri1\">" +
                "<root>" +
                "<ns0:child xmlns:ns0=\"uri2\">" +
                "<ns0:child2>Value text - no entities!</ns0:child2>" +
                "</ns0:child>" +
                "</root>" +
                "</verrryoot>",
                sXML);
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
/**
 * Test: declare all namespaces in the root element and use them in nested
 * elements
 */
@Test
public void testNamespaces3 ()
{
  final XMLWriterSettings xs = new XMLWriterSettings ();
  xs.setIndent (EXMLSerializeIndent.NONE);
  xs.setUseDoubleQuotesForAttributes (false);

  final String s = "<?xml version=\"1.0\"?>" +
                   "<verrryoot xmlns='uri1' xmlns:a='uri2'>" +
                   "<root>" +
                   "<a:child>" +
                   "<a:child2>Value text - no entities!</a:child2>" +
                   "</a:child>" +
                   "</root>" +
                   "</verrryoot>";
  final IMicroDocument aDoc = MicroReader.readMicroXML (s);
  assertNotNull (aDoc);

  final NonBlockingByteArrayOutputStream baos = new NonBlockingByteArrayOutputStream ();
  new MicroSerializer (xs).write (aDoc, baos);
  final String sXML = baos.getAsString (StandardCharsets.UTF_8);
  assertEquals ("<?xml version='1.0' encoding='UTF-8'?>" +
                "<verrryoot xmlns='uri1'>" +
                "<root>" +
                "<ns0:child xmlns:ns0='uri2'>" +
                "<ns0:child2>Value text - no entities!</ns0:child2>" +
                "</ns0:child>" +
                "</root>" +
                "</verrryoot>",
                sXML);
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Test
public void testSimple ()
{
  final IMicroDocument aDoc = new MicroDocument ();
  aDoc.appendElement ("test");
  assertNotNull (new MicroDOMInputStreamProvider (aDoc, XMLWriterSettings.DEFAULT_XML_CHARSET_OBJ).getInputStream ());
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
/**
 * @return The {@link IXMLWriterSettings} to be used to serialize the data.
 */
@Nonnull
@OverrideOnDemand
protected IXMLWriterSettings getXMLWriterSettings ()
{
  return XMLWriterSettings.DEFAULT_XML_SETTINGS;
}
 

import com.helger.xml.serialize.write.XMLWriterSettings; //导入依赖的package包/类
@Nonnull
public IPSWriterSettings setXMLWriterSettings (@Nonnull final IXMLWriterSettings aXMLWriterSettings)
{
  ValueEnforcer.notNull (aXMLWriterSettings, "XMLWriterSettings");
  m_aXMLWriterSettings = new XMLWriterSettings (aXMLWriterSettings);
  return this;
}