| /************************************************************** | |
| * | |
| * Licensed to the Apache Software Foundation (ASF) under one | |
| * or more contributor license agreements. See the NOTICE file | |
| * distributed with this work for additional information | |
| * regarding copyright ownership. The ASF licenses this file | |
| * to you under the Apache License, Version 2.0 (the | |
| * "License"); you may not use this file except in compliance | |
| * with the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, | |
| * software distributed under the License is distributed on an | |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY | |
| * KIND, either express or implied. See the License for the | |
| * specific language governing permissions and limitations | |
| * under the License. | |
| * | |
| *************************************************************/ | |
| #ifndef _SAXEVENTKEEPERIMPL_HXX | |
| #define _SAXEVENTKEEPERIMPL_HXX | |
| #include <com/sun/star/xml/crypto/sax/XSecuritySAXEventKeeper.hpp> | |
| #include <com/sun/star/xml/crypto/sax/XReferenceResolvedBroadcaster.hpp> | |
| #include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeBroadcaster.hpp> | |
| #include <com/sun/star/xml/crypto/sax/XSAXEventKeeperStatusChangeListener.hpp> | |
| #include <com/sun/star/xml/csax/XCompressedDocumentHandler.hpp> | |
| #include <com/sun/star/xml/wrapper/XXMLDocumentWrapper.hpp> | |
| #include <com/sun/star/xml/sax/XDocumentHandler.hpp> | |
| #include <com/sun/star/lang/XInitialization.hpp> | |
| #include <com/sun/star/lang/XServiceInfo.hpp> | |
| #include <cppuhelper/implbase6.hxx> | |
| #include "buffernode.hxx" | |
| #include "elementmark.hxx" | |
| #include "elementcollector.hxx" | |
| #ifndef INCLUDED_VECTOR | |
| #include <vector> | |
| #define INCLUDED_VECTOR | |
| #endif | |
| class SAXEventKeeperImpl : public cppu::WeakImplHelper6 | |
| < | |
| com::sun::star::xml::crypto::sax::XSecuritySAXEventKeeper, | |
| com::sun::star::xml::crypto::sax::XReferenceResolvedBroadcaster, | |
| com::sun::star::xml::crypto::sax::XSAXEventKeeperStatusChangeBroadcaster, | |
| com::sun::star::xml::sax::XDocumentHandler, | |
| com::sun::star::lang::XInitialization, | |
| com::sun::star::lang::XServiceInfo | |
| > | |
| /****** SAXEventKeeperImpl.hxx/CLASS SAXEventKeeperImpl *********************** | |
| * | |
| * NAME | |
| * SAXEventKeeperImpl -- SAX events buffer controller | |
| * | |
| * FUNCTION | |
| * Controls SAX events to be bufferred, and controls bufferred SAX events | |
| * to be released. | |
| * | |
| * HISTORY | |
| * 05.01.2004 - Interface supported: XSecuritySAXEventKeeper, | |
| * XReferenceResolvedBroadcaster, | |
| * XSAXEventKeeperStatusChangeBroadcaster, | |
| * XDocumentHandler, XInitialization, XServiceInfo | |
| * | |
| * AUTHOR | |
| * Michael Mi | |
| * Email: michael.mi@sun.com | |
| ******************************************************************************/ | |
| { | |
| private: | |
| /* | |
| * the XMLDocumentWrapper component which maintains all buffered SAX | |
| * in DOM format. | |
| */ | |
| com::sun::star::uno::Reference< | |
| com::sun::star::xml::wrapper::XXMLDocumentWrapper > | |
| m_xXMLDocument; | |
| /* | |
| * the document handler provided by the XMLDocumentWrapper component. | |
| */ | |
| com::sun::star::uno::Reference< | |
| com::sun::star::xml::sax::XDocumentHandler > m_xDocumentHandler; | |
| /* | |
| * the compressed document handler provided by the XMLDocumentWrapper | |
| * component, the handler has more efficient method definition that the | |
| * normal document handler. | |
| */ | |
| com::sun::star::uno::Reference< | |
| com::sun::star::xml::csax::XCompressedDocumentHandler > | |
| m_xCompressedDocumentHandler; | |
| /* | |
| * a listener which receives this SAXEventKeeper's status change | |
| * notification. | |
| * Based on the status changes, the listener can decide whether the | |
| * SAXEventKeeper should chain on/chain off the SAX chain, or whether | |
| * the SAXEventKeeper is useless any long. | |
| */ | |
| com::sun::star::uno::Reference< | |
| com::sun::star::xml::crypto::sax::XSAXEventKeeperStatusChangeListener > | |
| m_xSAXEventKeeperStatusChangeListener; | |
| /* | |
| * the root node of the BufferNode tree. | |
| * the BufferNode tree is used to keep track of all buffered elements, | |
| * it has the same structure with the document which maintains those | |
| * elements physically. | |
| */ | |
| BufferNode* m_pRootBufferNode; | |
| /* | |
| * the current active BufferNode. | |
| * this is used to keep track the current location in the BufferNode tree, | |
| * the next generated BufferNode will become a child BufferNode of it. | |
| */ | |
| BufferNode* m_pCurrentBufferNode; | |
| /* | |
| * the next Id for a coming ElementMark. | |
| * the variable is increased by 1 when an new ElementMark is generated, | |
| * in this way, we can promise the Id of any ElementMark is unique. | |
| */ | |
| sal_Int32 m_nNextElementMarkId; | |
| /* | |
| * maintains a collection of all ElementMarks. | |
| */ | |
| std::vector< const ElementMark* > m_vElementMarkBuffers; | |
| /* | |
| * maintains a list of new ElementCollectors that will be created | |
| * on the element represented by the next incoming startElement SAX | |
| * event. | |
| * The reason that such the m_vNewElementCollectors is necessary | |
| * is: when an ElementCollector is asked to create, it can't be | |
| * created completely at once, because the BufferNode it will be | |
| * working on has not been created until the next startElement | |
| * SAX event comes. | |
| */ | |
| std::vector< const ElementCollector* > m_vNewElementCollectors; | |
| /* | |
| * maintains the new Blocker that will be created | |
| * on the element represented by the next incoming startElement SAX | |
| * event. | |
| */ | |
| ElementMark* m_pNewBlocker; | |
| /* | |
| * the document handler to which all received SAX events will be | |
| * forwarded. | |
| */ | |
| com::sun::star::uno::Reference< | |
| com::sun::star::xml::sax::XDocumentHandler > m_xNextHandler; | |
| /* | |
| * the current BufferNode which prevents the SAX events to be | |
| * forwarded to the m_xNextHandler. | |
| */ | |
| BufferNode* m_pCurrentBlockingBufferNode; | |
| /* | |
| * maintains a list of ElementMark that has been asked to release. | |
| * Because during processing a request of releasing an ElementMark, | |
| * another releasing ElementMark request can be invoked. To avoid | |
| * reentering the same method, a such request only add that ElementMark | |
| * into this ElementMark list, then all ElementMarks will be processed in | |
| * order. | |
| */ | |
| std::vector< sal_Int32 > m_vReleasedElementMarkBuffers; | |
| /* | |
| * a flag to indicate whether the ElementMark releasing process is running. | |
| * When a releasing request comes, the assigned ElementMark is added to | |
| * the m_vReleasedElementMarkBuffers first, then this flag is checked. | |
| * If the ElementMark releasing process is not running, then call that | |
| * method. | |
| */ | |
| bool m_bIsReleasing; | |
| /* | |
| * a flag to indicate whether it is the "Forwarding" mode now. | |
| * A "Forwarding" mode means that all received SAX events are from the | |
| * XMLDocumentWrapper component, instead of up-stream component in the | |
| * SAX chain. | |
| * The difference between "Forwarding" mode and normal mode is that: | |
| * no SAX events need to be transferred to the XMLDocumentWrapper component | |
| * again even if a buffer request happens. | |
| */ | |
| bool m_bIsForwarding; | |
| void setCurrentBufferNode(BufferNode* pBufferNode); | |
| BufferNode* addNewElementMarkBuffers(); | |
| ElementMark* findElementMarkBuffer(sal_Int32 nId) const; | |
| void removeElementMarkBuffer(sal_Int32 nId); | |
| rtl::OUString printBufferNode( | |
| BufferNode* pBufferNode, sal_Int32 nIndent) const; | |
| com::sun::star::uno::Sequence< com::sun::star::uno::Reference< | |
| com::sun::star::xml::wrapper::XXMLElementWrapper > > | |
| collectChildWorkingElement(BufferNode* pBufferNode) const; | |
| void smashBufferNode( | |
| BufferNode* pBufferNode, bool bClearRoot) const; | |
| BufferNode* findNextBlockingBufferNode( | |
| BufferNode* pStartBufferNode) const; | |
| void diffuse(BufferNode* pBufferNode) const; | |
| void releaseElementMarkBuffer(); | |
| void markElementMarkBuffer(sal_Int32 nId); | |
| sal_Int32 createElementCollector( | |
| sal_Int32 nSecurityId, | |
| com::sun::star::xml::crypto::sax::ElementMarkPriority nPriority, | |
| bool bModifyElement, | |
| const com::sun::star::uno::Reference< | |
| com::sun::star::xml::crypto::sax::XReferenceResolvedListener>& | |
| xReferenceResolvedListener); | |
| sal_Int32 createBlocker(sal_Int32 nSecurityId); | |
| public: | |
| SAXEventKeeperImpl(); | |
| virtual ~SAXEventKeeperImpl(); | |
| /* XSAXEventKeeper */ | |
| virtual sal_Int32 SAL_CALL addElementCollector( ); | |
| virtual void SAL_CALL removeElementCollector( sal_Int32 id ); | |
| virtual sal_Int32 SAL_CALL addBlocker( ); | |
| virtual void SAL_CALL removeBlocker( sal_Int32 id ); | |
| virtual sal_Bool SAL_CALL isBlocking( ); | |
| virtual com::sun::star::uno::Reference< | |
| com::sun::star::xml::wrapper::XXMLElementWrapper > SAL_CALL | |
| getElement( sal_Int32 id ); | |
| virtual void SAL_CALL setElement( | |
| sal_Int32 id, | |
| const com::sun::star::uno::Reference< | |
| com::sun::star::xml::wrapper::XXMLElementWrapper >& | |
| aElement ); | |
| virtual com::sun::star::uno::Reference< | |
| com::sun::star::xml::sax::XDocumentHandler > SAL_CALL | |
| setNextHandler( const com::sun::star::uno::Reference< | |
| com::sun::star::xml::sax::XDocumentHandler >& xNewHandler ); | |
| virtual rtl::OUString SAL_CALL printBufferNodeTree(); | |
| virtual com::sun::star::uno::Reference< | |
| com::sun::star::xml::wrapper::XXMLElementWrapper > SAL_CALL | |
| getCurrentBlockingNode(); | |
| /* XSecuritySAXEventKeeper */ | |
| virtual sal_Int32 SAL_CALL addSecurityElementCollector( | |
| com::sun::star::xml::crypto::sax::ElementMarkPriority priority, | |
| sal_Bool modifyElement ); | |
| virtual sal_Int32 SAL_CALL cloneElementCollector( | |
| sal_Int32 referenceId, | |
| com::sun::star::xml::crypto::sax::ElementMarkPriority priority ); | |
| virtual void SAL_CALL setSecurityId( sal_Int32 id, sal_Int32 securityId ); | |
| /* XReferenceResolvedBroadcaster */ | |
| virtual void SAL_CALL addReferenceResolvedListener( | |
| sal_Int32 referenceId, | |
| const com::sun::star::uno::Reference< | |
| com::sun::star::xml::crypto::sax::XReferenceResolvedListener >& | |
| listener ); | |
| virtual void SAL_CALL removeReferenceResolvedListener( | |
| sal_Int32 referenceId, | |
| const com::sun::star::uno::Reference< | |
| com::sun::star::xml::crypto::sax::XReferenceResolvedListener >& | |
| listener ); | |
| /* XSAXEventKeeperStatusChangeBroadcaster */ | |
| virtual void SAL_CALL addSAXEventKeeperStatusChangeListener( | |
| const com::sun::star::uno::Reference< | |
| com::sun::star::xml::crypto::sax::XSAXEventKeeperStatusChangeListener >& | |
| listener ); | |
| virtual void SAL_CALL removeSAXEventKeeperStatusChangeListener( | |
| const com::sun::star::uno::Reference< | |
| com::sun::star::xml::crypto::sax::XSAXEventKeeperStatusChangeListener >& | |
| listener ); | |
| /* XDocumentHandler */ | |
| virtual void SAL_CALL startDocument( ); | |
| virtual void SAL_CALL endDocument( ); | |
| virtual void SAL_CALL startElement( | |
| const rtl::OUString& aName, | |
| const com::sun::star::uno::Reference< com::sun::star::xml::sax::XAttributeList >& | |
| xAttribs ); | |
| virtual void SAL_CALL endElement( const rtl::OUString& aName ); | |
| virtual void SAL_CALL characters( const rtl::OUString& aChars ); | |
| virtual void SAL_CALL ignorableWhitespace( const rtl::OUString& aWhitespaces ); | |
| virtual void SAL_CALL processingInstruction( | |
| const rtl::OUString& aTarget, const rtl::OUString& aData ); | |
| virtual void SAL_CALL setDocumentLocator( | |
| const com::sun::star::uno::Reference< com::sun::star::xml::sax::XLocator >& xLocator ); | |
| /* XInitialization */ | |
| virtual void SAL_CALL initialize( | |
| const com::sun::star::uno::Sequence< com::sun::star::uno::Any >& aArguments ); | |
| /* XServiceInfo */ | |
| virtual rtl::OUString SAL_CALL getImplementationName( ); | |
| virtual sal_Bool SAL_CALL supportsService( const rtl::OUString& ServiceName ); | |
| virtual com::sun::star::uno::Sequence< rtl::OUString > SAL_CALL getSupportedServiceNames( ); | |
| }; | |
| rtl::OUString SAXEventKeeperImpl_getImplementationName(); | |
| sal_Bool SAL_CALL SAXEventKeeperImpl_supportsService( const rtl::OUString& ServiceName ); | |
| com::sun::star::uno::Sequence< rtl::OUString > SAL_CALL SAXEventKeeperImpl_getSupportedServiceNames( ); | |
| com::sun::star::uno::Reference< com::sun::star::uno::XInterface > | |
| SAL_CALL SAXEventKeeperImpl_createInstance( const com::sun::star::uno::Reference< com::sun::star::lang::XMultiServiceFactory > & rSMgr); | |
| #endif |