sax/source/tools/fastattribs.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 <algorithm>
  21
  22 #include <com/sun/star/xml/sax/SAXException.hpp>
  23 #include <sax/fastattribs.hxx>
  24 #include <utility>
  25
  26 using namespace ::com::sun::star::uno;
  27 using namespace ::com::sun::star::xml;
  28 using namespace ::com::sun::star::xml::sax;
  29 namespace sax_fastparser
  30 {
  31
  32 // wastage to keep MSVC happy vs. an in-line {}
  33 FastTokenHandlerBase::~FastTokenHandlerBase()
  34 {
  35 }
  36
  37 UnknownAttribute::UnknownAttribute( OUString aNamespaceURL, OString aName, OString value )
  38     : maNamespaceURL(std::move( aNamespaceURL )), maName(std::move( aName )), maValue(std::move( value ))
  39 {
  40 }
  41
  42 UnknownAttribute::UnknownAttribute( OString aName, OString value )
  43     : maName(std::move( aName )), maValue(std::move( value ))
  44 {
  45 }
  46
  47 void UnknownAttribute::FillAttribute( Attribute* pAttrib ) const
  48 {
  49     if( pAttrib )
  50     {
  51         pAttrib->Name = OStringToOUString( maName, RTL_TEXTENCODING_UTF8 );
  52         pAttrib->NamespaceURL = maNamespaceURL;
  53         pAttrib->Value = OStringToOUString( maValue, RTL_TEXTENCODING_UTF8 );
  54     }
  55 }
  56
  57 FastAttributeList::FastAttributeList( sax_fastparser::FastTokenHandlerBase *pTokenHandler)
  58 : mpTokenHandler( pTokenHandler )
  59 {
  60     // random initial size of buffer to store attribute values
  61     mnChunkLength = 58;
  62     mpChunk = static_cast<char *>(malloc( mnChunkLength ));
  63     maAttributeValues.push_back( 0 );
  64 }
  65
  66 FastAttributeList::FastAttributeList( const css::uno::Reference< css::xml::sax::XFastAttributeList > & xAttrList )
  67 {
  68     const auto& rOther = castToFastAttributeList(xAttrList);
  69     mpTokenHandler = rOther.mpTokenHandler;
  70     mpChunk = static_cast<char *>(malloc( rOther.mnChunkLength ));
  71     mnChunkLength = rOther.mnChunkLength;
  72     memcpy(mpChunk, rOther.mpChunk, rOther.mnChunkLength);
  73     maAttributeValues = rOther.maAttributeValues;
  74     maAttributeTokens = rOther.maAttributeTokens;
  75     maUnknownAttributes = rOther.maUnknownAttributes;
  76 }
  77
  78 css::uno::Reference< ::css::util::XCloneable > FastAttributeList::createClone()
  79 {
  80     return new FastAttributeList(this);
  81 }
  82
  83 FastAttributeList::~FastAttributeList()
  84 {
  85     free( mpChunk );
  86 }
  87
  88 void FastAttributeList::clear()
  89 {
  90     maAttributeTokens.clear();
  91     maAttributeValues.resize(1);
  92     assert(maAttributeValues[0] == 0);
  93     maUnknownAttributes.clear();
  94 }
  95
  96 void FastAttributeList::add( sal_Int32 nToken, std::string_view value )
  97 {
  98     assert(nToken != -1);
  99     assert(nToken != 0);
 100     assert(value.length() < SAL_MAX_INT32); // protect against absurd values
 101     maAttributeTokens.push_back( nToken );
 102     sal_Int32 nWritePosition = maAttributeValues.back();
 103     maAttributeValues.push_back( maAttributeValues.back() + value.length() + 1 );
 104     if (maAttributeValues.back() > mnChunkLength)
 105     {
 106         const sal_Int32 newLen = std::max(mnChunkLength * 2, maAttributeValues.back());
 107         auto p = static_cast<char*>(realloc(mpChunk, newLen));
 108         if (!p)
 109             throw std::bad_alloc();
 110
 111         mnChunkLength = newLen;
 112         mpChunk = p;
 113
 114     }
 115     memcpy(mpChunk + nWritePosition, value.data(), value.length());
 116     mpChunk[nWritePosition + value.length()] = '\0';
 117 }
 118
 119 void FastAttributeList::add(sal_Int32 nToken, std::u16string_view sValue)
 120 {
 121     add(nToken, OUStringToOString(sValue, RTL_TEXTENCODING_UTF8));
 122 }
 123
 124 void FastAttributeList::addNS( sal_Int32 nNamespaceToken, sal_Int32 nToken, std::string_view rValue )
 125 {
 126     sal_Int32 nCombinedToken = (nNamespaceToken << 16) | nToken;
 127     add( nCombinedToken, rValue );
 128 }
 129
 130 void FastAttributeList::addNS(sal_Int32 nNamespaceToken, sal_Int32 nToken,
 131                                      std::u16string_view sValue)
 132 {
 133     sal_Int32 nCombinedToken = (nNamespaceToken << 16) | nToken;
 134     add(nCombinedToken, sValue);
 135 }
 136
 137 void FastAttributeList::addUnknown( const OUString& rNamespaceURL, const OString& rName, const OString& value )
 138 {
 139     maUnknownAttributes.emplace_back( rNamespaceURL, rName, value );
 140 }
 141
 142 void FastAttributeList::addUnknown( const OString& rName, const OString& value )
 143 {
 144     maUnknownAttributes.emplace_back( rName, value );
 145 }
 146
 147 void FastAttributeList::add( const css::uno::Reference<css::xml::sax::XFastAttributeList>& xAttrList )
 148 {
 149     const auto& rOther = castToFastAttributeList(xAttrList);
 150     add(rOther);
 151 }
 152
 153 void FastAttributeList::add( const FastAttributeList& rOther )
 154 {
 155     for (size_t i=0; i < rOther.maAttributeTokens.size(); ++i)
 156         add(rOther.maAttributeTokens[i], rOther.getAsViewByIndex(i));
 157     for (const auto & i : rOther.maUnknownAttributes)
 158         addUnknown(i.maNamespaceURL, i.maName, i.maValue);
 159 }
 160
 161 // XFastAttributeList
 162 sal_Bool FastAttributeList::hasAttribute( ::sal_Int32 Token )
 163 {
 164     for (sal_Int32 i : maAttributeTokens)
 165         if (i == Token)
 166             return true;
 167
 168     return false;
 169 }
 170
 171 sal_Int32 FastAttributeList::getValueToken( ::sal_Int32 Token )
 172 {
 173     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 174         if (maAttributeTokens[i] == Token)
 175             return getValueTokenByIndex(i);
 176
 177     throw SAXException("FastAttributeList::getValueToken: unknown token " + OUString::number(Token), nullptr, Any());
 178 }
 179
 180 sal_Int32 FastAttributeList::getOptionalValueToken( ::sal_Int32 Token, ::sal_Int32 Default )
 181 {
 182     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 183         if (maAttributeTokens[i] == Token)
 184             return getValueTokenByIndex(i);
 185
 186     return Default;
 187 }
 188
 189 // performance sensitive shortcuts to avoid allocation ...
 190 bool FastAttributeList::getAsInteger( sal_Int32 nToken, sal_Int32 &rInt) const
 191 {
 192     rInt = 0;
 193     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 194         if (maAttributeTokens[i] == nToken)
 195         {
 196             rInt = getAsIntegerByIndex(i);
 197             return true;
 198         }
 199     return false;
 200 }
 201
 202 bool FastAttributeList::getAsDouble( sal_Int32 nToken, double &rDouble) const
 203 {
 204     rDouble = 0.0;
 205     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 206         if (maAttributeTokens[i] == nToken)
 207         {
 208             rDouble = o3tl::toDouble(getAsViewByIndex(i));
 209             return true;
 210         }
 211     return false;
 212 }
 213
 214 bool FastAttributeList::getAsView( sal_Int32 nToken, std::string_view& rPos ) const
 215 {
 216     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 217     {
 218         if (maAttributeTokens[i] != nToken)
 219             continue;
 220
 221         rPos = getAsViewByIndex(i);
 222         return true;
 223     }
 224
 225     return false;
 226 }
 227
 228 OUString FastAttributeList::getValue( ::sal_Int32 Token )
 229 {
 230     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 231         if (maAttributeTokens[i] == Token)
 232             return getValueByIndex(i);
 233
 234     throw SAXException("FastAttributeList::getValue: unknown token " + OUString::number(Token), nullptr, Any());
 235 }
 236
 237 OUString FastAttributeList::getOptionalValue( ::sal_Int32 Token )
 238 {
 239     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 240         if (maAttributeTokens[i] == Token)
 241             return getValueByIndex(i);
 242
 243     return OUString();
 244 }
 245
 246 sal_Int32 FastAttributeList::getValueTokenByIndex(sal_Int32 nTokenIndex) const
 247 {
 248     return FastTokenHandlerBase::getTokenFromChars(mpTokenHandler, getAsViewByIndex(nTokenIndex));
 249 }
 250
 251 Sequence< Attribute > FastAttributeList::getUnknownAttributes(  )
 252 {
 253     auto nSize = maUnknownAttributes.size();
 254     if (nSize == 0)
 255         return {};
 256     Sequence< Attribute > aSeq( nSize );
 257     Attribute* pAttr = aSeq.getArray();
 258     for( const auto& rAttr : maUnknownAttributes )
 259         rAttr.FillAttribute( pAttr++ );
 260     return aSeq;
 261 }
 262 Sequence< FastAttribute > FastAttributeList::getFastAttributes(  )
 263 {
 264     Sequence< FastAttribute > aSeq( maAttributeTokens.size() );
 265     FastAttribute* pAttr = aSeq.getArray();
 266     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 267     {
 268         pAttr->Token = maAttributeTokens[i];
 269         pAttr->Value = getValueByIndex(i);
 270         pAttr++;
 271     }
 272     return aSeq;
 273 }
 274
 275 FastAttributeList::FastAttributeIter FastAttributeList::find( sal_Int32 nToken ) const
 276 {
 277     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 278         if( maAttributeTokens[i] == nToken )
 279             return FastAttributeIter(*this, i);
 280     return end();
 281 }
 282
 283 sal_Int32 FastTokenHandlerBase::getTokenFromChars(
 284         const FastTokenHandlerBase *pTokenHandler,
 285         std::string_view token )
 286 {
 287     return pTokenHandler->getTokenDirect(token);
 288 }
 289
 290 }
 291
 292 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */