sax/source/tools/fshelper.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  * This file incorporates work covered by the following license notice:
  10  *
  11  *   Licensed to the Apache Software Foundation (ASF) under one or more
  12  *   contributor license agreements. See the NOTICE file distributed
  13  *   with this work for additional information regarding copyright
  14  *   ownership. The ASF licenses this file to you under the Apache
  15  *   License, Version 2.0 (the "License"); you may not use this file
  16  *   except in compliance with the License. You may obtain a copy of
  17  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
  18  */
  19
  20 #include <sal/log.hxx>
  21 #include <sax/fshelper.hxx>
  22 #include "fastserializer.hxx"
  23
  24 using namespace ::com::sun::star;
  25 using namespace ::com::sun::star::uno;
  26
  27 namespace sax_fastparser {
  28
  29 FastSerializerHelper::FastSerializerHelper(const Reference< io::XOutputStream >& xOutputStream, bool bWriteHeader ) :
  30     mpSerializer(new FastSaxSerializer(xOutputStream))
  31 {
  32     if( bWriteHeader )
  33         startDocument();
  34 }
  35
  36 void FastSerializerHelper::startDocument()
  37 {
  38     mpSerializer->startDocument();
  39 }
  40
  41 void FastSerializerHelper::endDocument()
  42 {
  43     std::unique_ptr<FastSaxSerializer> xSerializer(std::move(mpSerializer));
  44     xSerializer->endDocument();
  45 }
  46
  47 FastSerializerHelper::~FastSerializerHelper()
  48 {
  49     if (mpSerializer)
  50     {
  51         assert(false && "call endDocument explicitly before dtor to avoid potential exceptions during dtor");
  52         endDocument();
  53     }
  54 }
  55
  56 void FastSerializerHelper::startElement(sal_Int32 elementTokenId)
  57 {
  58     mpSerializer->startFastElement(elementTokenId);
  59 }
  60 void FastSerializerHelper::pushAttributeValue(sal_Int32 attribute, const char* value)
  61 {
  62     mpSerializer->getTokenValueList().emplace_back(attribute, value);
  63 }
  64 void FastSerializerHelper::pushAttributeValue(sal_Int32 attribute, const OString& value)
  65 {
  66     mpSerializer->getTokenValueList().emplace_back(attribute, value.getStr());
  67 }
  68 void FastSerializerHelper::singleElement(sal_Int32 elementTokenId)
  69 {
  70     mpSerializer->singleFastElement(elementTokenId);
  71 }
  72
  73 void FastSerializerHelper::endElement(sal_Int32 elementTokenId)
  74 {
  75     mpSerializer->endFastElement(elementTokenId);
  76 }
  77
  78 void FastSerializerHelper::startElement(sal_Int32 elementTokenId, const rtl::Reference<FastAttributeList>& xAttrList)
  79 {
  80     assert(xAttrList);
  81     mpSerializer->startFastElement(elementTokenId, xAttrList.get());
  82 }
  83
  84 void FastSerializerHelper::singleElement(sal_Int32 elementTokenId, const rtl::Reference<FastAttributeList>& xAttrList)
  85 {
  86     assert(xAttrList);
  87     mpSerializer->singleFastElement(elementTokenId, xAttrList.get());
  88 }
  89
  90 FastSerializerHelper* FastSerializerHelper::write(const char* value)
  91 {
  92     mpSerializer->write(value, -1);
  93     return this;
  94 }
  95
  96 FastSerializerHelper* FastSerializerHelper::write(const OString& value)
  97 {
  98     mpSerializer->write(value);
  99     return this;
 100 }
 101
 102 FastSerializerHelper* FastSerializerHelper::write(std::u16string_view value)
 103 {
 104     mpSerializer->write(value);
 105     return this;
 106 }
 107
 108 FastSerializerHelper* FastSerializerHelper::write(sal_Int32 value)
 109 {
 110     mpSerializer->write(OString::number(value));
 111     return this;
 112 }
 113
 114 FastSerializerHelper* FastSerializerHelper::write(sal_Int64 value)
 115 {
 116     mpSerializer->write(OString::number(value));
 117     return this;
 118 }
 119
 120 FastSerializerHelper* FastSerializerHelper::write(double value)
 121 {
 122     mpSerializer->write(value);
 123     return this;
 124 }
 125
 126 FastSerializerHelper* FastSerializerHelper::writeEscaped(const char* value)
 127 {
 128     mpSerializer->write(value, -1, true);
 129     return this;
 130 }
 131
 132 FastSerializerHelper* FastSerializerHelper::writeEscaped(std::u16string_view value)
 133 {
 134     if (!value.empty())
 135         mpSerializer->write(value, true);
 136     return this;
 137 }
 138
 139 FastSerializerHelper* FastSerializerHelper::writeId(sal_Int32 tokenId)
 140 {
 141     mpSerializer->writeId(tokenId);
 142     return this;
 143 }
 144
 145 css::uno::Reference< css::io::XOutputStream > const & FastSerializerHelper::getOutputStream() const
 146 {
 147     return mpSerializer->getOutputStream();
 148 }
 149
 150 void FastSerializerHelper::mark(
 151         sal_Int32 const nTag, const Sequence<sal_Int32>& rOrder)
 152 {
 153     mpSerializer->mark(nTag, rOrder);
 154 }
 155
 156 void FastSerializerHelper::mergeTopMarks(
 157         sal_Int32 const nTag, MergeMarks const eMergeType)
 158 {
 159     mpSerializer->mergeTopMarks(nTag, eMergeType);
 160 }
 161
 162 rtl::Reference<FastAttributeList> FastSerializerHelper::createAttrList()
 163 {
 164     return new FastAttributeList( nullptr );
 165 }
 166
 167 void FastSerializerHelper::setAllowXEscape(bool bSet)
 168 {
 169     mpSerializer->setAllowXEscape(bSet);
 170 }
 171
 172 }
 173
 174 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */