tools/source/xml/XmlWriter.cxx

   1 /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
   2 /*
   3  * This file is part of the LibreOffice project.
   4  *
   5  * This Source Code Form is subject to the terms of the Mozilla Public
   6  * License, v. 2.0. If a copy of the MPL was not distributed with this
   7  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
   8  */
   9
  10 #include <tools/stream.hxx>
  11 #include <tools/XmlWriter.hxx>
  12
  13 #include <libxml/xmlwriter.h>
  14
  15 namespace tools
  16 {
  17 namespace
  18 {
  19 int funcWriteCallback(void* pContext, const char* sBuffer, int nLen)
  20 {
  21     SvStream* pStream = static_cast<SvStream*>(pContext);
  22     return static_cast<int>(pStream->WriteBytes(sBuffer, nLen));
  23 }
  24
  25 int funcCloseCallback(void* pContext)
  26 {
  27     SvStream* pStream = static_cast<SvStream*>(pContext);
  28     pStream->Flush();
  29     return 0; // 0 or -1 in case of error
  30 }
  31
  32 template <typename T>
  33 requires(sizeof(T) == sizeof(char)) void attributeBase64_impl(xmlTextWriterPtr writer,
  34                                                               const char* name, const T* value,
  35                                                               int size)
  36 {
  37     (void)xmlTextWriterStartAttribute(writer, BAD_CAST(name));
  38     (void)xmlTextWriterWriteBase64(writer, reinterpret_cast<const char*>(value), 0, size);
  39     (void)xmlTextWriterEndAttribute(writer);
  40 }
  41 } // end anonymous namespace
  42
  43 struct XmlWriterImpl
  44 {
  45     XmlWriterImpl(SvStream* pStream)
  46         : mpStream(pStream)
  47         , mpWriter(nullptr)
  48         , mbWriteXmlHeader(true)
  49     {
  50     }
  51
  52     SvStream* mpStream;
  53     xmlTextWriterPtr mpWriter;
  54     bool mbWriteXmlHeader;
  55 };
  56
  57 XmlWriter::XmlWriter(SvStream* pStream)
  58     : mpImpl(std::make_unique<XmlWriterImpl>(pStream))
  59 {
  60 }
  61
  62 XmlWriter::~XmlWriter()
  63 {
  64     if (mpImpl && mpImpl->mpWriter != nullptr)
  65         endDocument();
  66 }
  67
  68 bool XmlWriter::startDocument(sal_Int32 nIndent, bool bWriteXmlHeader)
  69 {
  70     mpImpl->mbWriteXmlHeader = bWriteXmlHeader;
  71     xmlCharEncodingHandlerPtr pEncodingHandler = xmlGetCharEncodingHandler(XML_CHAR_ENCODING_UTF8);
  72     xmlOutputBufferPtr xmlOutBuffer = xmlOutputBufferCreateIO(funcWriteCallback, funcCloseCallback,
  73                                                               mpImpl->mpStream, pEncodingHandler);
  74     mpImpl->mpWriter = xmlNewTextWriter(xmlOutBuffer);
  75     if (mpImpl->mpWriter == nullptr)
  76         return false;
  77     xmlTextWriterSetIndent(mpImpl->mpWriter, nIndent);
  78     if (mpImpl->mbWriteXmlHeader)
  79         (void)xmlTextWriterStartDocument(mpImpl->mpWriter, nullptr, "UTF-8", nullptr);
  80     return true;
  81 }
  82
  83 void XmlWriter::endDocument()
  84 {
  85     if (mpImpl->mbWriteXmlHeader)
  86         (void)xmlTextWriterEndDocument(mpImpl->mpWriter);
  87     xmlFreeTextWriter(mpImpl->mpWriter);
  88     mpImpl->mpWriter = nullptr;
  89 }
  90
  91 void XmlWriter::startElement(const OString& sPrefix, const OString& sName,
  92                              const OString& sNamespaceUri)
  93 {
  94     xmlChar* xmlName = BAD_CAST(sName.getStr());
  95     xmlChar* xmlPrefix = nullptr;
  96     xmlChar* xmlNamespaceUri = nullptr;
  97     if (!sPrefix.isEmpty())
  98         xmlPrefix = BAD_CAST(sPrefix.getStr());
  99     if (!sNamespaceUri.isEmpty())
 100         xmlNamespaceUri = BAD_CAST(sNamespaceUri.getStr());
 101
 102     (void)xmlTextWriterStartElementNS(mpImpl->mpWriter, xmlPrefix, xmlName, xmlNamespaceUri);
 103 }
 104
 105 void XmlWriter::startElement(const char* pName)
 106 {
 107     xmlChar* xmlName = BAD_CAST(pName);
 108     (void)xmlTextWriterStartElement(mpImpl->mpWriter, xmlName);
 109 }
 110
 111 void XmlWriter::endElement() { (void)xmlTextWriterEndElement(mpImpl->mpWriter); }
 112
 113 void XmlWriter::attributeBase64(const char* pName, std::vector<sal_uInt8> const& rValueInBytes)
 114 {
 115     attributeBase64_impl(mpImpl->mpWriter, pName, rValueInBytes.data(), rValueInBytes.size());
 116 }
 117
 118 void XmlWriter::attributeBase64(const char* pName, std::vector<char> const& rValueInBytes)
 119 {
 120     attributeBase64_impl(mpImpl->mpWriter, pName, rValueInBytes.data(), rValueInBytes.size());
 121 }
 122
 123 void XmlWriter::attribute(const char* name, const OString& value)
 124 {
 125     xmlChar* xmlName = BAD_CAST(name);
 126     xmlChar* xmlValue = BAD_CAST(value.getStr());
 127     (void)xmlTextWriterWriteAttribute(mpImpl->mpWriter, xmlName, xmlValue);
 128 }
 129
 130 void XmlWriter::attribute(const char* name, std::u16string_view value)
 131 {
 132     attribute(name, OUStringToOString(value, RTL_TEXTENCODING_UTF8));
 133 }
 134
 135 void XmlWriter::attribute(const char* name, const sal_Int64 aNumber)
 136 {
 137     attribute(name, OString::number(aNumber));
 138 }
 139
 140 void XmlWriter::attributeDouble(const char* name, const double aNumber)
 141 {
 142     attribute(name, OString::number(aNumber));
 143 }
 144
 145 void XmlWriter::content(const OString& sValue)
 146 {
 147     xmlChar* xmlValue = BAD_CAST(sValue.getStr());
 148     (void)xmlTextWriterWriteString(mpImpl->mpWriter, xmlValue);
 149 }
 150
 151 void XmlWriter::content(std::u16string_view sValue)
 152 {
 153     content(OUStringToOString(sValue, RTL_TEXTENCODING_UTF8));
 154 }
 155
 156 void XmlWriter::element(const char* sName)
 157 {
 158     startElement(sName);
 159     endElement();
 160 }
 161
 162 } // end tools namespace
 163
 164 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */