replace obsolete "master" branch with README that points at new repoHEADmaster-deletedmaster

1 files changed, 0 insertions, 1426 deletions

diff --git a/xmlsecurity/source/framework/saxeventkeeperimpl.cxx b/xmlsecurity/source/framework/saxeventkeeperimpl.cxx
deleted file mode 100644
index 076128eb1..000000000
--- a/xmlsecurity/source/framework/saxeventkeeperimpl.cxx
+++ /dev/null
@@ -1,1426 +0,0 @@
-/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
-/*************************************************************************
- *
- * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
- * 
- * Copyright 2000, 2010 Oracle and/or its affiliates.
- *
- * OpenOffice.org - a multi-platform office productivity suite
- *
- * This file is part of OpenOffice.org.
- *
- * OpenOffice.org is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License version 3
- * only, as published by the Free Software Foundation.
- *
- * OpenOffice.org is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License version 3 for more details
- * (a copy is included in the LICENSE file that accompanied this code).
- *
- * You should have received a copy of the GNU Lesser General Public License
- * version 3 along with OpenOffice.org.  If not, see
- * <http://www.openoffice.org/license.html>
- * for a copy of the LGPLv3 License.
- *
- ************************************************************************/
-
-// MARKER(update_precomp.py): autogen include statement, do not remove
-#include "precompiled_xmlsecurity.hxx"
-
-#include "saxeventkeeperimpl.hxx"
-#include <com/sun/star/lang/XMultiServiceFactory.hpp>
-#include <com/sun/star/xml/sax/XDocumentHandler.hpp>
-#include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp>
-
-namespace cssu = com::sun::star::uno;
-namespace cssl = com::sun::star::lang;
-namespace cssxc = com::sun::star::xml::crypto;
-namespace cssxcsax = com::sun::star::xml::csax;
-namespace cssxw = com::sun::star::xml::wrapper;
-namespace cssxs = com::sun::star::xml::sax;
-
-#define SERVICE_NAME "com.sun.star.xml.crypto.sax.SAXEventKeeper"
-#define IMPLEMENTATION_NAME "com.sun.star.xml.security.framework.SAXEventKeeperImpl"
-
-#define _USECOMPRESSEDDOCUMENTHANDLER
-
-SAXEventKeeperImpl::SAXEventKeeperImpl( )
-    :m_pRootBufferNode(NULL),
-     m_pCurrentBufferNode(NULL),
-     m_nNextElementMarkId(1),
-     m_pNewBlocker(NULL),
-     m_pCurrentBlockingBufferNode(NULL),
-     m_bIsReleasing(false),
-     m_bIsForwarding(false)
-{
-    m_vElementMarkBuffers.reserve(2);
-    m_vNewElementCollectors.reserve(2);
-    m_vReleasedElementMarkBuffers.reserve(2);
-}
-
-SAXEventKeeperImpl::~SAXEventKeeperImpl()
-{
-    /*
-     * delete the BufferNode tree
-     */
-    if (m_pRootBufferNode != NULL)
-    {
-        m_pRootBufferNode->freeAllChildren();
-        delete m_pRootBufferNode;
-    }
-    
-    m_pRootBufferNode = m_pCurrentBufferNode = m_pCurrentBlockingBufferNode = NULL;
-    
-    /*
-     * delete all unfreed ElementMarks
-     */
-    m_vNewElementCollectors.clear();
-    m_pNewBlocker = NULL;
-    
-    std::vector< const ElementMark* >::const_iterator ii = m_vElementMarkBuffers.begin();
-    for( ; ii != m_vElementMarkBuffers.end(); ++ii ) 
-    {
-        delete (*ii);
-    }
-    m_vElementMarkBuffers.clear();
-}
-
-void SAXEventKeeperImpl::setCurrentBufferNode(BufferNode* pBufferNode)
-/****** SAXEventKeeperImpl/setCurrentBufferNode ******************************
- *
- *   NAME
- *	setCurrentBufferNode -- set a new active BufferNode.
- *
- *   SYNOPSIS
- *	setCurrentBufferNode( pBufferNode );
- *
- *   FUNCTION
- *	connects this BufferNode into the BufferNode tree as a child of the
- *	current active BufferNode. Then makes this BufferNode as the current
- *	active BufferNode.
- *	If the previous active BufferNode points to the root
- *	BufferNode, which means that no buffering operation was proceeding,
- *	then notifies the status change listener that buffering  operation 
- *	will begin at once.
- *
- *   INPUTS
- *	pBufferNode - a BufferNode which will be the new active BufferNode
- *
- *   RESULT
- *	empty
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    if (pBufferNode != m_pCurrentBufferNode)
-    {
-        if ( m_pCurrentBufferNode == m_pRootBufferNode &&
-             m_xSAXEventKeeperStatusChangeListener.is())
-        {
-            m_xSAXEventKeeperStatusChangeListener->collectionStatusChanged(sal_True);
-        }
-            
-        if (pBufferNode->getParent() == NULL)
-        {
-            m_pCurrentBufferNode->addChild(pBufferNode);
-            pBufferNode->setParent(m_pCurrentBufferNode);
-        }
-        
-        m_pCurrentBufferNode = pBufferNode;
-    }
-}
-
-BufferNode* SAXEventKeeperImpl::addNewElementMarkBuffers()
-/****** SAXEventKeeperImpl/addNewElementMarkBuffers **************************
- *
- *   NAME
- *	addNewElementMarkBuffers -- add new ElementCollectors and new Blocker.
- *
- *   SYNOPSIS
- *	pBufferNode = addNewElementMarkBuffers( );
- *
- *   FUNCTION
- *	if there are new ElementCollector or new Blocker to be added, then
- *	connect all of them with the current BufferNode. In case of the
- *	current BufferNode doesn't exist, creates one.
- *	Clears up the new ElementCollector list and the new Blocker pointer.
- *
- *   INPUTS
- *	empty
- *
- *   RESULT
- *	pBufferNode - the BufferNode that has been connected with both new
- *	              ElementCollectors and new Blocker.
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    BufferNode* pBufferNode = NULL;
-
-    if ( (!m_vNewElementCollectors.empty()) ||
-         (m_pNewBlocker != NULL))
-    {
-        /*
-         * When the current BufferNode is right pointing to the current
-         * working element in the XMLDocumentWrapper component, then
-         * no new BufferNode is needed to create.
-         * This situation can only happen in the "Forwarding" mode.
-         */
-        if ( (m_pCurrentBufferNode != NULL) && 
-             (m_xXMLDocument->isCurrent(m_pCurrentBufferNode->getXMLElement())))
-        {
-            pBufferNode = m_pCurrentBufferNode;
-        }
-        else
-        {
-            pBufferNode = new BufferNode(m_xXMLDocument->getCurrentElement());
-        }
-            
-        if (m_pNewBlocker != NULL)
-        {
-            pBufferNode->setBlocker(m_pNewBlocker);
-            
-            /*
-             * If no blocking before, then notify the status change listener that
-             * the SAXEventKeeper has entered "blocking" status, during which, no
-             * SAX events will be forwarded to the next document handler.
-             */
-            if (m_pCurrentBlockingBufferNode == NULL)
-            {
-                m_pCurrentBlockingBufferNode = pBufferNode;
-                
-                if (m_xSAXEventKeeperStatusChangeListener.is())
-                {
-                    m_xSAXEventKeeperStatusChangeListener->blockingStatusChanged(sal_True);
-                }
-            }
-            
-            m_pNewBlocker = NULL;
-        }
-        
-        if (!m_vNewElementCollectors.empty())
-        {
-            std::vector< const ElementCollector* >::const_iterator ii = m_vNewElementCollectors.begin();
-            
-            for( ; ii != m_vNewElementCollectors.end(); ++ii ) 
-            {
-                pBufferNode->addElementCollector(*ii);
-            }
-        
-            m_vNewElementCollectors.clear();
-        }
-    }
-    
-    return pBufferNode;
-}
-
-ElementMark* SAXEventKeeperImpl::findElementMarkBuffer(sal_Int32 nId) const
-/****** SAXEventKeeperImpl/findElementMarkBuffer *****************************
- *
- *   NAME
- *	findElementMarkBuffer -- finds an ElementMark.
- *
- *   SYNOPSIS
- *	pElementMark = findElementMarkBuffer( nId );
- *
- *   FUNCTION
- *	searches an ElementMark with the particular Id in the ElementMark
- *	list.
- *
- *   INPUTS
- *	nId - the Id of the ElementMark to be searched.
- *
- *   RESULT
- *	pElementMark - the ElementMark with the particular Id, or NULL when 
- *	               no such Id exists.
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    ElementMark* pElementMark = NULL;
-    
-    std::vector< const ElementMark* >::const_iterator ii = m_vElementMarkBuffers.begin();
-            
-    for( ; ii != m_vElementMarkBuffers.end(); ++ii ) 
-    {
-        if ( nId == (*ii)->getBufferId())
-        {
-            pElementMark = (ElementMark*)*ii;
-            break;
-        }
-    }
-    
-    return pElementMark;
-}
-
-void SAXEventKeeperImpl::removeElementMarkBuffer(sal_Int32 nId)
-/****** SAXEventKeeperImpl/removeElementMarkBuffer ***************************
- *
- *   NAME
- *	removeElementMarkBuffer -- removes an ElementMark
- *
- *   SYNOPSIS
- *	removeElementMarkBuffer( nId );
- *
- *   FUNCTION
- *	removes an ElementMark with the particular Id in the ElementMark list.
- *
- *   INPUTS
- *	nId - the Id of the ElementMark to be removed.
- *
- *   RESULT
- *	empty
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    std::vector< const ElementMark* >::iterator ii = m_vElementMarkBuffers.begin();
-            
-    for( ; ii != m_vElementMarkBuffers.end(); ++ii ) 
-    {
-        if ( nId == (*ii)->getBufferId())
-        {
-            /*
-             * checks whether this ElementMark still in the new ElementCollect array
-             */
-            std::vector< const ElementCollector* >::iterator jj = m_vNewElementCollectors.begin();
-            for( ; jj != m_vNewElementCollectors.end(); ++jj ) 
-            {
-                if ((*ii) == (*jj))
-                {
-                    m_vNewElementCollectors.erase(jj);
-                    break;
-                }
-            }
-            
-            /*
-             * checks whether this ElementMark is the new Blocker
-             */
-            if ((*ii) == m_pNewBlocker)
-            {
-                m_pNewBlocker = NULL;
-            }
-            
-            /*
-             * destory the ElementMark
-             */
-            delete (*ii);
-            
-            m_vElementMarkBuffers.erase( ii );
-            break;
-        }
-    }
-}
-
-rtl::OUString SAXEventKeeperImpl::printBufferNode(
-    BufferNode* pBufferNode, sal_Int32 nIndent) const
-/****** SAXEventKeeperImpl/printBufferNode ***********************************
- *
- *   NAME
- *	printBufferNode -- retrieves the information of a BufferNode and its
- *	branch.
- *
- *   SYNOPSIS
- *	info = printBufferNode( pBufferNode, nIndent );
- *
- *   FUNCTION
- *	all retrieved information includes:
- *	1. whether it is the current BufferNode;
- *	2. whether it is the current blocking BufferNode;
- *	3. the name of the parent element;
- *	4. the name of this element;
- *	5. all ElementCollectors working on this BufferNode;
- *	6. the Blocker working on this BufferNode;
- *	7. all child BufferNodes' information.
- *
- *   INPUTS
- *	pBufferNode - 	the BufferNode from where information will be retrieved.
- *	nIndent - 	how many space characters prefixed before the output
- *	          	message.
- *
- *   RESULT
- *	info - the information string
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    rtl::OUString rc;
-
-    for ( int i=0; i<nIndent; ++i )
-    {
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " ));
-    }
-
-    if (pBufferNode == m_pCurrentBufferNode)
-    {
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[%]" ));
-    }
-        
-    if (pBufferNode == m_pCurrentBlockingBufferNode)
-    {
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[B]" ));
-    }
-
-    rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " ));
-    rc += m_xXMLDocument->getNodeName(pBufferNode->getXMLElement());
-    
-    BufferNode* pParent = (BufferNode*)pBufferNode->getParent();
-    if (pParent != NULL)
-    {
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[" ));
-        rc += m_xXMLDocument->getNodeName(pParent->getXMLElement());
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "]" ));
-    }
-    
-    rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ":EC=" ));
-    rc += pBufferNode->printChildren();
-    rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " BR=" ));
-        
-    ElementMark * pBlocker = pBufferNode->getBlocker();
-    if (pBlocker != NULL)
-    {
-        rc += rtl::OUString::valueOf( pBlocker->getBufferId() );
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "(SecId=" ));
-        rc += rtl::OUString::valueOf( pBlocker->getSecurityId() );
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ")" ));
-        rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " ));
-    }
-    rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\n" ));
-        
-    std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren();
-    std::vector< const BufferNode* >::const_iterator jj = vChildren->begin();
-    for( ; jj != vChildren->end(); ++jj ) 
-    {
-        rc += printBufferNode((BufferNode *)*jj, nIndent+4);
-    }
-    
-    delete vChildren;
-    
-    return rc;
-}
-
-cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > > 
-    SAXEventKeeperImpl::collectChildWorkingElement(BufferNode* pBufferNode) const
-/****** SAXEventKeeperImpl/collectChildWorkingElement ************************
- *
- *   NAME
- *	collectChildWorkingElement -- collects a BufferNode's all child
- *	Elements.
- *
- *   SYNOPSIS
- *	list = collectChildWorkingElement( pBufferNode );
- *
- *   FUNCTION
- *	see NAME.
- *
- *   INPUTS
- *	pBufferNode - the BufferNode whose child Elements will be collected.
- *
- *   RESULT
- *	list - the child Elements list.
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren();
-    
-    cssu::Sequence < cssu::Reference< 
-        cssxw::XXMLElementWrapper > > aChildrenCollection ( vChildren->size());
-    
-    std::vector< const BufferNode* >::const_iterator ii = vChildren->begin();
-    
-    sal_Int32 nIndex = 0;
-    for( ; ii != vChildren->end(); ++ii ) 
-    {
-        aChildrenCollection[nIndex] = (*ii)->getXMLElement();
-        nIndex++;
-    }
-    
-    delete vChildren;
-    
-    return aChildrenCollection;
-}
-
-void SAXEventKeeperImpl::smashBufferNode(
-    BufferNode* pBufferNode, bool bClearRoot) const
-/****** SAXEventKeeperImpl/smashBufferNode ***********************************
- *
- *   NAME
- *	smashBufferNode -- removes a BufferNode along with its working
- *	element.
- *
- *   SYNOPSIS
- *	smashBufferNode( pBufferNode, bClearRoot );
- *
- *   FUNCTION
- *	removes the BufferNode's working element from the DOM document, while
- *	reserves all ancestor paths for its child BufferNodes.
- *	when any of the BufferNode's ancestor element is useless, removes it
- *	too.
- *	removes the BufferNode from the BufferNode tree.
- *
- *   INPUTS
- *	pBufferNode - 	the BufferNode to be removed
- *	bClearRoot - 	whether the root element also needs to be cleared up.
- *
- *   RESULT
- *	empty
- *
- *   NOTES
- *	when removeing a Blocker's BufferNode, the bClearRoot flag should be
- *	true. Because a Blocker can buffer many SAX events which are not used
- *	by any other ElementCollector or Blocker.
- *	When the bClearRoot is set to true, the root BufferNode will be first
- *	cleared, with a stop flag seting at the next Blocking BufferNode. This
- *	operation can delete all useless bufferred SAX events which are only
- *	needed by the Blocker to be deleted.
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    if (!pBufferNode->hasAnything())
-    {
-        BufferNode* pParent = (BufferNode*)pBufferNode->getParent();
-        
-            /*
-             * delete the XML data
-             */
-        if (pParent == m_pRootBufferNode)
-        {
-            bool bIsNotBlocking = (m_pCurrentBlockingBufferNode == NULL);
-            bool bIsBlockInside = false;
-            bool bIsBlockingAfterward = false;
-            
-                /*
-                 * If this is a blocker, then remove any out-element data
-                 * which caused by blocking. The removal process will stop
-                 * at the next blokcer to avoid removing any useful data.
-                 */
-            if (bClearRoot)
-            {
-                cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > > 
-                    aChildElements = collectChildWorkingElement(m_pRootBufferNode);
-                
-                    /*
-                     * the clearUselessData only clearup the content in the 
-                     * node, not the node itself.
-                     */
-                m_xXMLDocument->clearUselessData(m_pRootBufferNode->getXMLElement(),
-                    aChildElements,
-                    bIsNotBlocking?(NULL):
-                                   (m_pCurrentBlockingBufferNode->getXMLElement()));
-                    
-                    /*
-                     * remove the node if it is empty, then if its parent is also
-                     * empty, remove it, then if the next parent is also empty,
-                     * remove it,..., until parent become null.
-                     */
-                m_xXMLDocument->collapse( m_pRootBufferNode->getXMLElement() );
-            }
-            
-            /*
-             * if blocking, check the relationship between this BufferNode and 
-             * the current blocking BufferNode.
-             */
-            if ( !bIsNotBlocking )
-            {
-                /*
-                 * the current blocking BufferNode is a descendant of this BufferNode.
-                 */
-                bIsBlockInside = (NULL != pBufferNode->isAncestor(m_pCurrentBlockingBufferNode));
-                
-                /*
-                 * the current blocking BufferNode locates behind this BufferNode in tree
-                 * order.
-                 */
-                bIsBlockingAfterward = pBufferNode->isPrevious(m_pCurrentBlockingBufferNode);
-            }
-            
-            /*
-             * this BufferNode's working element needs to be deleted only when
-             * 1. there is no blocking, or
-             * 2. the current blocking BufferNode is a descendant of this BufferNode, 
-             *    (then in the BufferNode's working element, the useless data before the blocking
-             *     element should be deleted.) or
-             * 3. the current blocking BufferNode is locates behind this BufferNode in tree,
-             *    (then the useless data between the blocking element and the working element
-             *     should be deleted.).
-             * Otherwise, this working element should not be deleted.
-             */
-            if ( bIsNotBlocking || bIsBlockInside || bIsBlockingAfterward )
-            {
-                cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > > 
-                    aChildElements = collectChildWorkingElement(pBufferNode);
-                
-                    /*
-                     * the clearUselessData only clearup the content in the 
-                     * node, not the node itself.
-                     */
-                m_xXMLDocument->clearUselessData(pBufferNode->getXMLElement(),
-                    aChildElements,
-                    bIsBlockInside?(m_pCurrentBlockingBufferNode->getXMLElement()):
-                               (NULL));
-                    
-                    /*
-                     * remove the node if it is empty, then if its parent is also
-                     * empty, remove it, then if the next parent is also empty,
-                     * remove it,..., until parent become null.
-                     */
-                m_xXMLDocument->collapse( pBufferNode->getXMLElement() );
-            }
-        }
-
-        sal_Int32 nIndex = pParent->indexOfChild(pBufferNode);
-
-        std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren();
-        pParent->removeChild(pBufferNode);
-        pBufferNode->setParent(NULL);
-        
-        std::vector< const BufferNode * >::const_iterator ii = vChildren->begin();
-        for( ; ii != vChildren->end(); ++ii ) 
-        {
-            ((BufferNode *)(*ii))->setParent(pParent);
-            pParent->addChild(*ii, nIndex);
-            nIndex++;
-        }
-        
-        delete vChildren;
-        
-        /*
-         * delete the BufferNode
-         */
-        delete pBufferNode;
-    }
-}
-
-BufferNode* SAXEventKeeperImpl::findNextBlockingBufferNode(
-    BufferNode* pStartBufferNode) const
-/****** SAXEventKeeperImpl/findNextBlockingBufferNode ************************
- *
- *   NAME
- *	findNextBlockingBufferNode -- finds the next blocking BufferNode
- *	behind the particular BufferNode.
- *
- *   SYNOPSIS
- *	pBufferNode = findNextBlockingBufferNode( pStartBufferNode );
- *
- *   FUNCTION
- *	see NAME.
- *
- *   INPUTS
- *	pStartBufferNode - the BufferNode from where to search the next 
- *	                   blocking BufferNode.
- *
- *   RESULT
- *	pBufferNode - the next blocking BufferNode, or NULL if no such 
- *	              BufferNode exists.
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    BufferNode* pNext = NULL;
-    
-    if (pStartBufferNode != NULL)
-    {
-        pNext = pStartBufferNode;
-        
-        while (NULL != (pNext = (BufferNode*)pNext->getNextNodeByTreeOrder()))
-        {
-            if (pNext->getBlocker() != NULL)
-            {
-                break;
-            }
-        }
-    }
-        
-    return pNext;
-}
-
-void SAXEventKeeperImpl::diffuse(BufferNode* pBufferNode) const
-/****** SAXEventKeeperImpl/diffuse *******************************************
- *
- *   NAME
- *	diffuse -- diffuse the notification.
- *
- *   SYNOPSIS
- *	diffuse( pBufferNode );
- *
- *   FUNCTION
- *	diffuse the collecting completion notification from the specific
- *	BufferNode along its parent link, until an ancestor which is not
- *	completely received is met.
- *
- *   INPUTS
- *	pBufferNode - the BufferNode from which the notification will be 
- *	              diffused.
- *
- *   RESULT
- *	empty
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    BufferNode* pParent = pBufferNode;
-    
-    while(pParent->isAllReceived())
-    {
-        pParent->elementCollectorNotify();
-        pParent = (BufferNode*)pParent->getParent();
-    }
-}
-
-void SAXEventKeeperImpl::releaseElementMarkBuffer()
-/****** SAXEventKeeperImpl/releaseElementMarkBuffer **************************
- *
- *   NAME
- *	releaseElementMarkBuffer -- releases useless ElementMarks 
- *
- *   SYNOPSIS
- *	releaseElementMarkBuffer( );
- *
- *   FUNCTION
- *	releases each ElementMark in the releasing list
- *	m_vReleasedElementMarkBuffers.
- *	The operation differs between an ElementCollector and a Blocker.
- *
- *   INPUTS
- *	empty
- *
- *   RESULT
- *	empty
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    m_bIsReleasing = true;
-    while (!m_vReleasedElementMarkBuffers.empty())
-    {
-        std::vector< sal_Int32 >::iterator pId = m_vReleasedElementMarkBuffers.begin();
-        sal_Int32 nId = *pId;
-        m_vReleasedElementMarkBuffers.erase( pId );
-        
-        ElementMark* pElementMark = findElementMarkBuffer(nId);
-
-        if (pElementMark != NULL)
-        {
-            if (cssxc::sax::ElementMarkType_ELEMENTCOLLECTOR 
-                == pElementMark->getType()) 
-            /*
-             * it is a EC
-             */
-            {
-                ElementCollector* pElementCollector = (ElementCollector*)pElementMark;
-                    
-                cssxc::sax::ElementMarkPriority nPriority = pElementCollector->getPriority();
-                bool bToModify = pElementCollector->getModify();
-                
-                /*
-                     * Delete the EC from the buffer node.
-                     */
-                BufferNode* pBufferNode = pElementCollector->getBufferNode();
-                pBufferNode->removeElementCollector(pElementCollector);
-
-                if ( nPriority == cssxc::sax::ElementMarkPriority_BEFOREMODIFY)
-                {
-                    pBufferNode->notifyBranch();
-                }
-                        
-                if (bToModify)
-                {
-                    pBufferNode->notifyAncestor();
-                }
-                
-                /*
-                 * delete the ElementMark
-                 */		 
-                pElementCollector = NULL;
-                pElementMark = NULL;
-                removeElementMarkBuffer(nId);			
-                
-                /*
-                 * delete the BufferNode
-                 */
-                diffuse(pBufferNode);
-                smashBufferNode(pBufferNode, false);
-            }
-            else 
-            /*
-             * it is a Blocker
-             */
-            {
-                    /*
-                     * Delete the TH from the buffer node.
-                     */
-                BufferNode *pBufferNode = pElementMark->getBufferNode();
-                pBufferNode->setBlocker(NULL);
-                
-                    /*
-                     * If there is a following handler and no blocking now, then
-                     * forward this event
-                     */
-                if (m_pCurrentBlockingBufferNode == pBufferNode)
-                {
-                        /*
-                         * Before forwarding, the next blocking point needs to be 
-                         * found.
-                         */
-                    m_pCurrentBlockingBufferNode = findNextBlockingBufferNode(pBufferNode);
-                            
-                        /*
-                         * Forward the blocked events between these two STHs.
-                         */
-                           if (m_xNextHandler.is())
-                           {
-                               BufferNode* pTempCurrentBufferNode = m_pCurrentBufferNode;
-                               BufferNode* pTempCurrentBlockingBufferNode = m_pCurrentBlockingBufferNode;
-                                           
-                               m_pCurrentBufferNode = pBufferNode;
-                               m_pCurrentBlockingBufferNode = NULL;
-                                           
-                        m_bIsForwarding = true;
-
-                        m_xXMLDocument->generateSAXEvents(
-                            m_xNextHandler,
-                            this,
-                            pBufferNode->getXMLElement(),
-                            (pTempCurrentBlockingBufferNode == NULL)?NULL:(pTempCurrentBlockingBufferNode->getXMLElement()));
-
-                        m_bIsForwarding = false;
-                                
-                        m_pCurrentBufferNode = pTempCurrentBufferNode;
-                        if (m_pCurrentBlockingBufferNode == NULL)
-                        {
-                            m_pCurrentBlockingBufferNode = pTempCurrentBlockingBufferNode;
-                        }
-                    }
-                            
-                    if (m_pCurrentBlockingBufferNode == NULL && 
-                        m_xSAXEventKeeperStatusChangeListener.is())
-                    {
-                        m_xSAXEventKeeperStatusChangeListener->blockingStatusChanged(sal_False);
-                    }
-                }
-
-                /*
-                 * delete the ElementMark
-                 */		 
-                pElementMark = NULL;
-                removeElementMarkBuffer(nId);
-                        
-                /*
-                 * delete the BufferNode
-                 */
-                diffuse(pBufferNode);
-                smashBufferNode(pBufferNode, true);
-            }
-        }
-    }
-        
-    m_bIsReleasing = false;
-        
-    if (!m_pRootBufferNode->hasAnything() && 
-        !m_pRootBufferNode->hasChildren() && 
-        m_xSAXEventKeeperStatusChangeListener.is())
-    {
-        m_xSAXEventKeeperStatusChangeListener->bufferStatusChanged(sal_True);
-    }
-}
-
-void SAXEventKeeperImpl::markElementMarkBuffer(sal_Int32 nId)
-/****** SAXEventKeeperImpl/markElementMarkBuffer *****************************
- *
- *   NAME
- *	markElementMarkBuffer -- marks an ElementMark to be released
- *
- *   SYNOPSIS
- *	markElementMarkBuffer( nId );
- *
- *   FUNCTION
- *	puts the ElementMark with the particular Id into the releasing list,
- *	checks whether the releasing process is runing, if not then launch 
- *	this process.
- *
- *   INPUTS
- *	nId - the Id of the ElementMark which will be released
- *
- *   RESULT
- *	empty
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    m_vReleasedElementMarkBuffers.push_back( nId );
-    if ( !m_bIsReleasing )
-    {
-        releaseElementMarkBuffer();
-    }
-}
-
-sal_Int32 SAXEventKeeperImpl::createElementCollector(
-    sal_Int32 nSecurityId,
-    cssxc::sax::ElementMarkPriority nPriority,
-    bool bModifyElement,
-    const cssu::Reference< cssxc::sax::XReferenceResolvedListener >& xReferenceResolvedListener)
-/****** SAXEventKeeperImpl/createElementCollector ****************************
- *
- *   NAME
- *	createElementCollector -- creates a new ElementCollector on the
- *	incoming element.
- *
- *   SYNOPSIS
- *	nId = createElementCollector( nSecurityId, nPriority,
- *	                             bModifyElement,
- *	                             xReferenceResolvedListener );
- *
- *   FUNCTION
- *	allocs a new Id, then create an ElementCollector with this Id value.
- *	Add the new created ElementCollector to the new ElementCollecotor list.
- *
- *   INPUTS
- *	nSecurityId - 	the security Id of the new ElementCollector
- *	nPriority - 	the prirority of the new ElementCollector
- *	bModifyElement -whether this BufferNode will modify the content of
- *	                the corresponding element it works on
- *	xReferenceResolvedListener - the listener for the new ElementCollector.
- *
- *   RESULT
- *	nId - the Id of the new ElementCollector
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    sal_Int32 nId = m_nNextElementMarkId;
-    m_nNextElementMarkId ++;
-    
-    ElementCollector* pElementCollector 
-        = new ElementCollector(
-            nSecurityId,
-            nId,
-            nPriority,
-            bModifyElement,
-            xReferenceResolvedListener);
-                
-    m_vElementMarkBuffers.push_back( pElementCollector );
-        
-        /*
-         * All the new EC to initial EC array.
-         */
-    m_vNewElementCollectors.push_back( pElementCollector );
-        
-    return nId;
-}
-
-    
-sal_Int32 SAXEventKeeperImpl::createBlocker(sal_Int32 nSecurityId)
-/****** SAXEventKeeperImpl/createBlocker *************************************
- *
- *   NAME
- *	createBlocker -- creates a new Blocker on the incoming element.
- *
- *   SYNOPSIS
- *	nId = createBlocker( nSecurityId );
- *
- *   FUNCTION
- *	see NAME.
- *
- *   INPUTS
- *	nSecurityId - 	the security Id of the new Blocker
- *
- *   RESULT
- *	nId - the Id of the new Blocker
- *
- *   AUTHOR
- *	Michael Mi
- *	Email: michael.mi@sun.com
- ******************************************************************************/
-{
-    sal_Int32 nId = m_nNextElementMarkId;
-    m_nNextElementMarkId ++;
-
-    OSL_ASSERT(m_pNewBlocker == NULL);
-
-    m_pNewBlocker = new ElementMark(nSecurityId, nId);
-    m_vElementMarkBuffers.push_back( m_pNewBlocker );
-        
-    return nId;
-}
-
-/* XSAXEventKeeper */
-sal_Int32 SAL_CALL SAXEventKeeperImpl::addElementCollector(  )
-    throw (cssu::RuntimeException)
-{
-    return createElementCollector(
-        cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID,
-        cssxc::sax::ElementMarkPriority_AFTERMODIFY,
-        false,
-        NULL);
-}
-
-void SAL_CALL SAXEventKeeperImpl::removeElementCollector( sal_Int32 id )
-    throw (cssu::RuntimeException)
-{
-    markElementMarkBuffer(id);
-}
-    
-sal_Int32 SAL_CALL SAXEventKeeperImpl::addBlocker(  )
-    throw (cssu::RuntimeException)
-{
-    return createBlocker(cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID);
-}
-    
-void SAL_CALL SAXEventKeeperImpl::removeBlocker( sal_Int32 id )
-    throw (cssu::RuntimeException)
-{
-    markElementMarkBuffer(id);
-}
-    
-sal_Bool SAL_CALL SAXEventKeeperImpl::isBlocking(  )
-    throw (cssu::RuntimeException)
-{
-    return (m_pCurrentBlockingBufferNode != NULL);
-}
-    
-cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL 
-    SAXEventKeeperImpl::getElement( sal_Int32 id )
-    throw (cssu::RuntimeException)
-{
-    cssu::Reference< cssxw::XXMLElementWrapper > rc;
-    
-    ElementMark* pElementMark = findElementMarkBuffer(id);
-    if (pElementMark != NULL)
-    {
-        rc = pElementMark->getBufferNode()->getXMLElement();
-    }
-    
-    return rc;
-}
-
-void SAL_CALL SAXEventKeeperImpl::setElement( 
-    sal_Int32 id, 
-    const cssu::Reference< cssxw::XXMLElementWrapper >& aElement )
-    throw (cssu::RuntimeException)
-{
-    if (aElement.is())
-    {
-        m_xXMLDocument->rebuildIDLink(aElement);
-        
-        ElementMark* pElementMark = findElementMarkBuffer(id);
-    
-        if (pElementMark != NULL)
-        {
-            BufferNode* pBufferNode = pElementMark->getBufferNode();
-            if (pBufferNode != NULL)
-            {
-                    bool bIsCurrent = m_xXMLDocument->isCurrent(pBufferNode->getXMLElement());
-                pBufferNode->setXMLElement(aElement);
-                
-                if (bIsCurrent)
-                {
-                    m_xXMLDocument->setCurrentElement(aElement);
-                }
-            }
-        }
-    }
-    else
-    {
-        removeElementCollector( id );
-    }
-}
-    
-cssu::Reference< cssxs::XDocumentHandler > SAL_CALL SAXEventKeeperImpl::setNextHandler(
-    const cssu::Reference< cssxs::XDocumentHandler >& xNewHandler )
-    throw (cssu::RuntimeException)
-{
-    cssu::Reference< cssxs::XDocumentHandler > xOldHandler = m_xNextHandler;
-    
-    m_xNextHandler = xNewHandler;
-    return xOldHandler;
-}
-    
-rtl::OUString SAL_CALL SAXEventKeeperImpl::printBufferNodeTree()
-    throw (cssu::RuntimeException)
-{
-    rtl::OUString rc;
-    
-    rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "ElementMarkBuffers: size = " ));
-    rc += rtl::OUString::valueOf((sal_Int32)m_vElementMarkBuffers.size());
-    rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\nCurrentBufferNode: " ));
-    rc += m_xXMLDocument->getNodeName(m_pCurrentBufferNode->getXMLElement());
-    rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "\n" ));
-    rc += printBufferNode(m_pRootBufferNode, 0);
-    
-    return rc;
-}
-    
-cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL SAXEventKeeperImpl::getCurrentBlockingNode()
-    throw (cssu::RuntimeException)
-{
-    cssu::Reference< cssxw::XXMLElementWrapper > rc;
-    
-    if (m_pCurrentBlockingBufferNode != NULL)
-    {
-        rc = m_pCurrentBlockingBufferNode->getXMLElement();
-    }
-    
-    return rc;
-}
-
-/* XSecuritySAXEventKeeper */
-sal_Int32 SAL_CALL SAXEventKeeperImpl::addSecurityElementCollector( 
-    cssxc::sax::ElementMarkPriority priority,
-    sal_Bool modifyElement )
-    throw (cssu::RuntimeException)
-{
-    return createElementCollector(
-        cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID,
-        priority,
-        modifyElement,
-        NULL);
-}
-    
-sal_Int32 SAL_CALL SAXEventKeeperImpl::cloneElementCollector(
-    sal_Int32 referenceId,
-    cssxc::sax::ElementMarkPriority priority )
-    throw (cssu::RuntimeException)
-{
-    sal_Int32 nId = -1;
-    
-    ElementCollector* pElementCollector = (ElementCollector*)findElementMarkBuffer(referenceId);
-    if (pElementCollector != NULL)
-    {
-        nId = m_nNextElementMarkId;
-        m_nNextElementMarkId ++;
-            
-        ElementCollector* pClonedOne 
-            = pElementCollector->clone(nId, priority);
-            
-            /*
-             * add this EC into the security data buffer array.
-             */
-        m_vElementMarkBuffers.push_back(pClonedOne);
-
-            /*
-             * If the reference EC is still in initial EC array, add
-             * this cloned one into the initial EC array too.
-             */
-            if (pElementCollector->getBufferNode() == NULL)
-        {
-            m_vNewElementCollectors.push_back(pClonedOne);
-        }
-    }
-    
-    return nId;
-}
-    
-void SAL_CALL SAXEventKeeperImpl::setSecurityId( sal_Int32 id, sal_Int32 securityId )
-    throw (cssu::RuntimeException)
-{
-    ElementMark* pElementMark = findElementMarkBuffer(id);
-    if (pElementMark != NULL)
-    {
-        pElementMark->setSecurityId(securityId);
-    }
-}
-
-    
-/* XReferenceResolvedBroadcaster */
-void SAL_CALL SAXEventKeeperImpl::addReferenceResolvedListener(
-    sal_Int32 referenceId,
-    const cssu::Reference< cssxc::sax::XReferenceResolvedListener >& listener )
-    throw (cssu::RuntimeException)
-{
-    ElementCollector* pElementCollector = (ElementCollector*)findElementMarkBuffer(referenceId);
-    if (pElementCollector != NULL)
-    {
-        pElementCollector->setReferenceResolvedListener(listener);
-    }
-}
-    
-void SAL_CALL SAXEventKeeperImpl::removeReferenceResolvedListener( 
-    sal_Int32 /*referenceId*/, 
-    const cssu::Reference< cssxc::sax::XReferenceResolvedListener >&)
-    throw (cssu::RuntimeException)
-{
-}
-    
-/* XSAXEventKeeperStatusChangeBroadcaster */
-void SAL_CALL SAXEventKeeperImpl::addSAXEventKeeperStatusChangeListener(
-    const cssu::Reference< cssxc::sax::XSAXEventKeeperStatusChangeListener >& listener )
-    throw (cssu::RuntimeException)
-{
-    m_xSAXEventKeeperStatusChangeListener = listener;
-}
-    
-void SAL_CALL SAXEventKeeperImpl::removeSAXEventKeeperStatusChangeListener(
-    const cssu::Reference< cssxc::sax::XSAXEventKeeperStatusChangeListener >&)
-    throw (cssu::RuntimeException)
-{
-}
-    
-/* XDocumentHandler */
-void SAL_CALL SAXEventKeeperImpl::startDocument(  )
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-    if ( m_xNextHandler.is())
-    {
-        m_xNextHandler->startDocument();
-    }
-}
-    
-void SAL_CALL SAXEventKeeperImpl::endDocument(  )
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-    if ( m_xNextHandler.is())
-    {
-        m_xNextHandler->endDocument();
-    }
-}
-    
-void SAL_CALL SAXEventKeeperImpl::startElement(
-    const rtl::OUString& aName,
-    const cssu::Reference< cssxs::XAttributeList >& xAttribs )
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-        /*
-         * If there is a following handler and no blocking now, then
-         * forward this event
-         */
-    if ((m_pCurrentBlockingBufferNode == NULL) &&
-        (m_xNextHandler.is()) && 
-        (!m_bIsForwarding) && 
-        (m_pNewBlocker == NULL))
-    {
-        m_xNextHandler->startElement(aName, xAttribs);
-    }
-
-        /*
-         * If not forwarding, buffer this startElement.
-         */
-           if (!m_bIsForwarding)
-           {
-    #ifndef _USECOMPRESSEDDOCUMENTHANDLER
-        m_xDocumentHandler->startElement(aName, xAttribs);
-    #else
-        sal_Int32 nLength = xAttribs->getLength();
-        cssu::Sequence< cssxcsax::XMLAttribute > aAttributes (nLength);
-        
-        for ( int i = 0; i<nLength; ++i ) 
-        {
-            aAttributes[i].sName = xAttribs->getNameByIndex((short)i);
-            aAttributes[i].sValue =xAttribs->getValueByIndex((short)i);
-        }
-        
-        m_xCompressedDocumentHandler->_startElement(aName, aAttributes);
-    #endif	       		
-               
-    }
-        
-    BufferNode* pBufferNode = addNewElementMarkBuffers();
-        if (pBufferNode != NULL)
-        {
-        setCurrentBufferNode(pBufferNode);
-    }
-}
-    
-void SAL_CALL SAXEventKeeperImpl::endElement( const rtl::OUString& aName ) 
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-        sal_Bool bIsCurrent = m_xXMLDocument->isCurrent(m_pCurrentBufferNode->getXMLElement());
-            
-        /*
-         * If there is a following handler and no blocking now, then
-         * forward this event
-         */
-    if ((m_pCurrentBlockingBufferNode == NULL) && 
-        (m_xNextHandler.is()) && 
-        (!m_bIsForwarding))
-    {
-        m_xNextHandler->endElement(aName);
-    }
-        
-    if ((m_pCurrentBlockingBufferNode != NULL) || 
-        (m_pCurrentBufferNode != m_pRootBufferNode) || 
-        (!m_xXMLDocument->isCurrentElementEmpty()))
-    {
-            if (!m_bIsForwarding)
-            {
-        #ifndef _USECOMPRESSEDDOCUMENTHANDLER
-            m_xDocumentHandler->endElement(aName);
-        #else
-            m_xCompressedDocumentHandler->_endElement(aName);
-        #endif	       		
-        }
-                
-        /*
-        * If the current buffer node has not notified yet, and 
-        * the current buffer node is waiting for the current element,
-        * then let it notify.
-        */
-           if (bIsCurrent && (m_pCurrentBufferNode != m_pRootBufferNode))
-        {
-            BufferNode* pOldCurrentBufferNode = m_pCurrentBufferNode;
-            m_pCurrentBufferNode = (BufferNode*)m_pCurrentBufferNode->getParent();
-            
-            pOldCurrentBufferNode->setReceivedAll();
-                
-            if ((m_pCurrentBufferNode == m_pRootBufferNode) && 
-                m_xSAXEventKeeperStatusChangeListener.is())
-            {
-                m_xSAXEventKeeperStatusChangeListener->collectionStatusChanged(sal_False);
-            }
-        }
-    }
-    else
-    {
-        if (!m_bIsForwarding)
-        {
-            m_xXMLDocument->removeCurrentElement();
-        }
-    }
-}
-    
-void SAL_CALL SAXEventKeeperImpl::characters( const rtl::OUString& aChars )
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-    if (!m_bIsForwarding)
-    {
-        if ((m_pCurrentBlockingBufferNode == NULL) && m_xNextHandler.is())
-        {
-            m_xNextHandler->characters(aChars);
-        }
-        
-        if ((m_pCurrentBlockingBufferNode != NULL) || 
-            (m_pCurrentBufferNode != m_pRootBufferNode))
-        {
-        #ifndef _USECOMPRESSEDDOCUMENTHANDLER
-                m_xDocumentHandler->characters(aChars);
-        #else
-            m_xCompressedDocumentHandler->_characters(aChars);
-        #endif	       		
-            }
-        }
-}
-    
-void SAL_CALL SAXEventKeeperImpl::ignorableWhitespace( const rtl::OUString& aWhitespaces )
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-    characters( aWhitespaces );
-}
-    
-void SAL_CALL SAXEventKeeperImpl::processingInstruction( 
-    const rtl::OUString& aTarget, const rtl::OUString& aData )
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-    if (!m_bIsForwarding)
-    {
-        if ((m_pCurrentBlockingBufferNode == NULL) && m_xNextHandler.is())
-        {
-            m_xNextHandler->processingInstruction(aTarget, aData);
-        }
-        
-        if ((m_pCurrentBlockingBufferNode != NULL) || 
-            (m_pCurrentBufferNode != m_pRootBufferNode))
-        {
-        #ifndef _USECOMPRESSEDDOCUMENTHANDLER
-            m_xDocumentHandler->processingInstruction(aTarget, aData);
-        #else
-            m_xCompressedDocumentHandler->_processingInstruction(aTarget, aData);
-        #endif	       		
-            }
-        }
-}
-    
-void SAL_CALL SAXEventKeeperImpl::setDocumentLocator( const cssu::Reference< cssxs::XLocator >&)
-    throw (cssxs::SAXException, cssu::RuntimeException)
-{
-}
-    
-/* XInitialization */
-void SAL_CALL SAXEventKeeperImpl::initialize( const cssu::Sequence< cssu::Any >& aArguments ) 
-    throw (cssu::Exception, cssu::RuntimeException)
-{
-    OSL_ASSERT(aArguments.getLength() == 1);
-    
-    aArguments[0] >>= m_xXMLDocument;
-    m_xDocumentHandler = cssu::Reference< cssxs::XDocumentHandler >( 
-        m_xXMLDocument, cssu::UNO_QUERY );
-    m_xCompressedDocumentHandler = cssu::Reference< cssxcsax::XCompressedDocumentHandler >( 
-        m_xXMLDocument, cssu::UNO_QUERY );
-    
-    m_pRootBufferNode = new BufferNode(m_xXMLDocument->getCurrentElement());
-    m_pCurrentBufferNode = m_pRootBufferNode;
-}
-    
-rtl::OUString SAXEventKeeperImpl_getImplementationName ()
-    throw (cssu::RuntimeException)
-{
-    return rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM ( IMPLEMENTATION_NAME ) );
-}
-
-sal_Bool SAL_CALL SAXEventKeeperImpl_supportsService( const rtl::OUString& ServiceName ) 
-    throw (cssu::RuntimeException)
-{
-    return ServiceName.equalsAsciiL( RTL_CONSTASCII_STRINGPARAM ( SERVICE_NAME ));
-}
-
-cssu::Sequence< rtl::OUString > SAL_CALL SAXEventKeeperImpl_getSupportedServiceNames(  ) 
-    throw (cssu::RuntimeException)
-{
-    cssu::Sequence < rtl::OUString > aRet(1);
-    rtl::OUString* pArray = aRet.getArray();
-    pArray[0] =  rtl::OUString ( RTL_CONSTASCII_USTRINGPARAM ( SERVICE_NAME ) );
-    return aRet;
-}
-#undef SERVICE_NAME
-
-cssu::Reference< cssu::XInterface > SAL_CALL SAXEventKeeperImpl_createInstance( 
-    const cssu::Reference< cssl::XMultiServiceFactory > &)
-    throw( cssu::Exception )
-{
-    return (cppu::OWeakObject*) new SAXEventKeeperImpl();
-}
-
-/* XServiceInfo */
-rtl::OUString SAL_CALL SAXEventKeeperImpl::getImplementationName(  ) 
-    throw (cssu::RuntimeException)
-{
-    return SAXEventKeeperImpl_getImplementationName();
-}
-sal_Bool SAL_CALL SAXEventKeeperImpl::supportsService( const rtl::OUString& rServiceName ) 
-    throw (cssu::RuntimeException)
-{
-    return SAXEventKeeperImpl_supportsService( rServiceName );
-}
-cssu::Sequence< rtl::OUString > SAL_CALL SAXEventKeeperImpl::getSupportedServiceNames(  ) 
-    throw (cssu::RuntimeException)
-{
-    return SAXEventKeeperImpl_getSupportedServiceNames();
-}
-
-/* vim:set shiftwidth=4 softtabstop=4 expandtab: */