oox/source/core/fastparser.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/config.h>
  21
  22 #include <com/sun/star/xml/sax/FastParser.hpp>
  23 #include "oox/core/fastparser.hxx"
  24
  25 #include "oox/core/fasttokenhandler.hxx"
  26 #include "oox/helper/containerhelper.hxx"
  27 #include "oox/helper/helper.hxx"
  28 #include "oox/helper/storagebase.hxx"
  29 #include "oox/token/namespacemap.hxx"
  30
  31 #include "sax/fastparser.hxx"
  32
  33 namespace oox {
  34 namespace core {
  35
  36 using namespace ::com::sun::star::io;
  37 using namespace ::com::sun::star::lang;
  38 using namespace ::com::sun::star::uno;
  39 using namespace ::com::sun::star::xml::sax;
  40
  41 namespace {
  42
  43 class InputStreamCloseGuard
  44 {
  45 public:
  46     explicit            InputStreamCloseGuard( const Reference< XInputStream >& rxInStream, bool bCloseStream );
  47                         ~InputStreamCloseGuard();
  48 private:
  49     Reference< XInputStream > mxInStream;
  50     bool                mbCloseStream;
  51 };
  52
  53 InputStreamCloseGuard::InputStreamCloseGuard( const Reference< XInputStream >& rxInStream, bool bCloseStream ) :
  54     mxInStream( rxInStream ),
  55     mbCloseStream( bCloseStream )
  56 {
  57 }
  58
  59 InputStreamCloseGuard::~InputStreamCloseGuard()
  60 {
  61     if( mxInStream.is() && mbCloseStream ) try { mxInStream->closeInput(); } catch( Exception& ) {}
  62 }
  63
  64 } // namespace
  65
  66 FastParser::FastParser() :
  67     mrNamespaceMap( StaticNamespaceMap::get() )
  68 {
  69     // create a fast parser instance
  70     mxParser = new sax_fastparser::FastSaxParser;
  71
  72     // create the fast tokenhandler
  73     mxTokenHandler.set( new FastTokenHandler );
  74
  75     // create the fast token handler based on the OOXML token list
  76     mxParser->setTokenHandler( mxTokenHandler );
  77 }
  78
  79 FastParser::~FastParser()
  80 {
  81 }
  82
  83 void FastParser::registerNamespace( sal_Int32 nNamespaceId )
  84 {
  85     if( !mxParser.is() )
  86         throw RuntimeException();
  87
  88     // add handling for OOXML strict here
  89     const OUString* pNamespaceUrl = ContainerHelper::getMapElement( mrNamespaceMap.maTransitionalNamespaceMap, nNamespaceId );
  90     if( !pNamespaceUrl )
  91         throw IllegalArgumentException();
  92
  93     mxParser->registerNamespace( *pNamespaceUrl, nNamespaceId );
  94
  95     //also register the OOXML strict namespaces for the same id
  96     const OUString* pNamespaceStrictUrl = ContainerHelper::getMapElement( mrNamespaceMap.maStrictNamespaceMap, nNamespaceId );
  97     if(pNamespaceStrictUrl && (*pNamespaceUrl != *pNamespaceStrictUrl))
  98     {
  99         mxParser->registerNamespace( *pNamespaceStrictUrl, nNamespaceId );
 100     }
 101 }
 102
 103 void FastParser::setDocumentHandler( const Reference< XFastDocumentHandler >& rxDocHandler )
 104 {
 105     if( !mxParser.is() )
 106         throw RuntimeException();
 107     mxParser->setFastDocumentHandler( rxDocHandler );
 108 }
 109
 110 void FastParser::clearDocumentHandler()
 111 {
 112     if (!mxParser.is())
 113         return;
 114     mxParser->setFastDocumentHandler(nullptr);
 115 }
 116
 117 void FastParser::parseStream( const InputSource& rInputSource, bool bCloseStream )
 118 {
 119     // guard closing the input stream also when exceptions are thrown
 120     InputStreamCloseGuard aGuard( rInputSource.aInputStream, bCloseStream );
 121     if( !mxParser.is() )
 122         throw RuntimeException();
 123     mxParser->parseStream( rInputSource );
 124 }
 125
 126 void FastParser::parseStream( const Reference< XInputStream >& rxInStream, const OUString& rStreamName )
 127 {
 128     InputSource aInputSource;
 129     aInputSource.sSystemId = rStreamName;
 130     aInputSource.aInputStream = rxInStream;
 131     parseStream( aInputSource );
 132 }
 133
 134 void FastParser::parseStream( StorageBase& rStorage, const OUString& rStreamName )
 135 {
 136     parseStream( rStorage.openInputStream( rStreamName ), rStreamName );
 137 }
 138
 139 } // namespace core
 140 } // namespace oox
 141
 142 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */