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 <sax/fastattribs.hxx>
  23
  24 using namespace ::com::sun::star::uno;
  25 using namespace ::com::sun::star::xml;
  26 using namespace ::com::sun::star::xml::sax;
  27 namespace sax_fastparser
  28 {
  29
  30 // wasteage to keep MSVC happy vs. an in-line {}
  31 FastTokenHandlerBase::~FastTokenHandlerBase()
  32 {
  33 }
  34
  35 UnknownAttribute::UnknownAttribute( const OUString& rNamespaceURL, const OString& rName, const OString& value )
  36     : maNamespaceURL( rNamespaceURL ), maName( rName ), maValue( value )
  37 {
  38 }
  39
  40 UnknownAttribute::UnknownAttribute( const OString& rName, const OString& value )
  41     : maName( rName ), maValue( value )
  42 {
  43 }
  44
  45 void UnknownAttribute::FillAttribute( Attribute* pAttrib ) const
  46 {
  47     if( pAttrib )
  48     {
  49         pAttrib->Name = OStringToOUString( maName, RTL_TEXTENCODING_UTF8 );
  50         pAttrib->NamespaceURL = maNamespaceURL;
  51         pAttrib->Value = OStringToOUString( maValue, RTL_TEXTENCODING_UTF8 );
  52     }
  53 }
  54
  55 FastAttributeList::FastAttributeList( const ::com::sun::star::uno::Reference< ::com::sun::star::xml::sax::XFastTokenHandler >& xTokenHandler,
  56                                       sax_fastparser::FastTokenHandlerBase *pTokenHandler)
  57 : mxTokenHandler( xTokenHandler ),
  58   mpTokenHandler( pTokenHandler )
  59 {
  60     // random initial size of buffer to store attribute values
  61     mnChunkLength = 58;
  62     mpChunk = static_cast<sal_Char *>(malloc( mnChunkLength ));
  63     maAttributeValues.push_back( 0 );
  64 }
  65
  66 FastAttributeList::~FastAttributeList()
  67 {
  68     free( mpChunk );
  69 }
  70
  71 void FastAttributeList::clear()
  72 {
  73     maAttributeTokens.clear();
  74     maAttributeValues.resize(1);
  75     assert(maAttributeValues[0] == 0);
  76     if (!maUnknownAttributes.empty())
  77         maUnknownAttributes.clear();
  78 }
  79
  80 void FastAttributeList::add( sal_Int32 nToken, const sal_Char* pValue, size_t nValueLength )
  81 {
  82     maAttributeTokens.push_back( nToken );
  83     sal_Int32 nWritePosition = maAttributeValues.back();
  84     maAttributeValues.push_back( maAttributeValues.back() + nValueLength + 1 );
  85     if (maAttributeValues.back() > mnChunkLength)
  86     {
  87         mnChunkLength = maAttributeValues.back();
  88         mpChunk = static_cast<sal_Char *>(realloc( mpChunk, mnChunkLength ));
  89     }
  90     strncpy(mpChunk + nWritePosition, pValue, nValueLength);
  91     mpChunk[nWritePosition + nValueLength] = '\0';
  92 }
  93
  94 void FastAttributeList::add( sal_Int32 nToken, const sal_Char* pValue )
  95 {
  96     add( nToken, pValue, strlen( pValue ));
  97 }
  98
  99 void FastAttributeList::add( sal_Int32 nToken, const OString& rValue )
 100 {
 101     add( nToken, rValue.getStr(), rValue.getLength() );
 102 }
 103
 104 void FastAttributeList::addNS( sal_Int32 nNamespaceToken, sal_Int32 nToken, const OString& rValue )
 105 {
 106     sal_Int32 nCombinedToken = (nNamespaceToken << 16) | nToken;
 107     add( nCombinedToken, rValue );
 108 }
 109
 110 void FastAttributeList::addUnknown( const OUString& rNamespaceURL, const OString& rName, const OString& value )
 111 {
 112     maUnknownAttributes.push_back( UnknownAttribute( rNamespaceURL, rName, value ) );
 113 }
 114
 115 void FastAttributeList::addUnknown( const OString& rName, const OString& value )
 116 {
 117     maUnknownAttributes.push_back( UnknownAttribute( rName, value ) );
 118 }
 119
 120 // XFastAttributeList
 121 sal_Bool FastAttributeList::hasAttribute( ::sal_Int32 Token ) throw (RuntimeException, std::exception)
 122 {
 123     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 124         if (maAttributeTokens[i] == Token)
 125             return sal_True;
 126
 127     return sal_False;
 128 }
 129
 130 sal_Int32 FastAttributeList::getValueToken( ::sal_Int32 Token ) throw (SAXException, RuntimeException, std::exception)
 131 {
 132     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 133         if (maAttributeTokens[i] == Token)
 134             return FastTokenHandlerBase::getTokenFromChars(
 135                        mxTokenHandler, mpTokenHandler,
 136                        getFastAttributeValue(i),
 137                        AttributeValueLength( i ) );
 138
 139     throw SAXException();
 140 }
 141
 142 sal_Int32 FastAttributeList::getOptionalValueToken( ::sal_Int32 Token, ::sal_Int32 Default ) throw (RuntimeException, std::exception)
 143 {
 144     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 145         if (maAttributeTokens[i] == Token)
 146             return FastTokenHandlerBase::getTokenFromChars(
 147                        mxTokenHandler, mpTokenHandler,
 148                        getFastAttributeValue(i),
 149                        AttributeValueLength( i ) );
 150
 151     return Default;
 152 }
 153
 154 // performance sensitive shortcuts to avoid allocation ...
 155 bool FastAttributeList::getAsInteger( sal_Int32 nToken, sal_Int32 &rInt)
 156 {
 157     rInt = 0;
 158     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 159         if (maAttributeTokens[i] == nToken)
 160         {
 161             rInt = rtl_str_toInt32( getFastAttributeValue(i), 10 );
 162             return true;
 163         }
 164     return false;
 165 }
 166
 167 bool FastAttributeList::getAsDouble( sal_Int32 nToken, double &rDouble)
 168 {
 169     rDouble = 0.0;
 170     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 171         if (maAttributeTokens[i] == nToken)
 172         {
 173             rDouble = rtl_str_toDouble( getFastAttributeValue(i) );
 174             return true;
 175         }
 176     return false;
 177 }
 178
 179 bool FastAttributeList::getAsChar( sal_Int32 nToken, const char*& rPos ) const
 180 {
 181     for (size_t i = 0, n = maAttributeTokens.size(); i < n; ++i)
 182     {
 183         if (maAttributeTokens[i] != nToken)
 184             continue;
 185
 186         sal_Int32 nOffset = maAttributeValues[i];
 187         rPos = mpChunk + nOffset;
 188         return true;
 189     }
 190
 191     return false;
 192 }
 193
 194 OUString FastAttributeList::getValue( ::sal_Int32 Token ) throw (SAXException, RuntimeException, std::exception)
 195 {
 196     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 197         if (maAttributeTokens[i] == Token)
 198             return OUString( getFastAttributeValue(i), AttributeValueLength(i), RTL_TEXTENCODING_UTF8 );
 199
 200     throw SAXException();
 201 }
 202
 203 OUString FastAttributeList::getOptionalValue( ::sal_Int32 Token ) throw (RuntimeException, std::exception)
 204 {
 205     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 206         if (maAttributeTokens[i] == Token)
 207             return OUString( getFastAttributeValue(i), AttributeValueLength(i), RTL_TEXTENCODING_UTF8 );
 208
 209     return OUString();
 210 }
 211 Sequence< Attribute > FastAttributeList::getUnknownAttributes(  ) throw (RuntimeException, std::exception)
 212 {
 213     Sequence< Attribute > aSeq( maUnknownAttributes.size() );
 214     Attribute* pAttr = aSeq.getArray();
 215     for( UnknownAttributeList::iterator attrIter = maUnknownAttributes.begin(); attrIter != maUnknownAttributes.end(); ++attrIter )
 216         (*attrIter).FillAttribute( pAttr++ );
 217     return aSeq;
 218 }
 219 Sequence< FastAttribute > FastAttributeList::getFastAttributes(  ) throw (RuntimeException, std::exception)
 220 {
 221     Sequence< FastAttribute > aSeq( maAttributeTokens.size() );
 222     FastAttribute* pAttr = aSeq.getArray();
 223     for (size_t i = 0; i < maAttributeTokens.size(); ++i)
 224     {
 225         pAttr->Token = maAttributeTokens[i];
 226         pAttr->Value = OUString( getFastAttributeValue(i), AttributeValueLength(i), RTL_TEXTENCODING_UTF8 );
 227         pAttr++;
 228     }
 229     return aSeq;
 230 }
 231
 232 sal_Int32 FastTokenHandlerBase::getTokenFromChars(
 233         const css::uno::Reference< css::xml::sax::XFastTokenHandler > &xTokenHandler,
 234         FastTokenHandlerBase *pTokenHandler,
 235         const char *pToken, size_t nLen /* = 0 */ )
 236 {
 237     sal_Int32 nRet;
 238
 239     if( !nLen )
 240         nLen = strlen( pToken );
 241
 242     if( pTokenHandler )
 243         nRet = pTokenHandler->getTokenDirect( pToken, (sal_Int32) nLen );
 244     else
 245     {
 246         // heap allocate, copy & then free
 247         Sequence< sal_Int8 > aSeq( reinterpret_cast<sal_Int8 const *>(pToken), nLen );
 248         nRet = xTokenHandler->getTokenFromUTF8( aSeq );
 249     }
 250
 251     return nRet;
 252 }
 253
 254 }
 255
 256 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */