xmlsecurity/source/framework/saxeventkeeperimpl.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
  21 #include "saxeventkeeperimpl.hxx"
  22 #include <com/sun/star/lang/XMultiServiceFactory.hpp>
  23 #include <com/sun/star/xml/sax/XDocumentHandler.hpp>
  24 #include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp>
  25 #include <cppuhelper/supportsservice.hxx>
  26 #include <osl/diagnose.h>
  27
  28 namespace cssu = com::sun::star::uno;
  29 namespace cssl = com::sun::star::lang;
  30 namespace cssxc = com::sun::star::xml::crypto;
  31 namespace cssxcsax = com::sun::star::xml::csax;
  32 namespace cssxw = com::sun::star::xml::wrapper;
  33 namespace cssxs = com::sun::star::xml::sax;
  34
  35 #define IMPLEMENTATION_NAME "com.sun.star.xml.security.framework.SAXEventKeeperImpl"
  36
  37 #define _USECOMPRESSEDDOCUMENTHANDLER
  38
  39 SAXEventKeeperImpl::SAXEventKeeperImpl( )
  40     :m_pRootBufferNode(NULL),
  41      m_pCurrentBufferNode(NULL),
  42      m_nNextElementMarkId(1),
  43      m_pNewBlocker(NULL),
  44      m_pCurrentBlockingBufferNode(NULL),
  45      m_bIsReleasing(false),
  46      m_bIsForwarding(false)
  47 {
  48     m_vElementMarkBuffers.reserve(2);
  49     m_vNewElementCollectors.reserve(2);
  50     m_vReleasedElementMarkBuffers.reserve(2);
  51 }
  52
  53 SAXEventKeeperImpl::~SAXEventKeeperImpl()
  54 {
  55     /*
  56      * delete the BufferNode tree
  57      */
  58     if (m_pRootBufferNode != NULL)
  59     {
  60         m_pRootBufferNode->freeAllChildren();
  61         delete m_pRootBufferNode;
  62     }
  63
  64     m_pRootBufferNode = m_pCurrentBufferNode = m_pCurrentBlockingBufferNode = NULL;
  65
  66     /*
  67      * delete all unfreed ElementMarks
  68      */
  69     m_vNewElementCollectors.clear();
  70     m_pNewBlocker = NULL;
  71
  72     std::vector< const ElementMark* >::const_iterator ii = m_vElementMarkBuffers.begin();
  73     for( ; ii != m_vElementMarkBuffers.end(); ++ii )
  74     {
  75         delete (*ii);
  76     }
  77     m_vElementMarkBuffers.clear();
  78 }
  79
  80 void SAXEventKeeperImpl::setCurrentBufferNode(BufferNode* pBufferNode)
  81 /****** SAXEventKeeperImpl/setCurrentBufferNode ******************************
  82  *
  83  *   NAME
  84  *  setCurrentBufferNode -- set a new active BufferNode.
  85  *
  86  *   SYNOPSIS
  87  *  setCurrentBufferNode( pBufferNode );
  88  *
  89  *   FUNCTION
  90  *  connects this BufferNode into the BufferNode tree as a child of the
  91  *  current active BufferNode. Then makes this BufferNode as the current
  92  *  active BufferNode.
  93  *  If the previous active BufferNode points to the root
  94  *  BufferNode, which means that no buffering operation was proceeding,
  95  *  then notifies the status change listener that buffering  operation
  96  *  will begin at once.
  97  *
  98  *   INPUTS
  99  *  pBufferNode - a BufferNode which will be the new active BufferNode
 100  *
 101  *   RESULT
 102  *  empty
 103  *
 104  *   AUTHOR
 105  *  Michael Mi
 106  *  Email: michael.mi@sun.com
 107  ******************************************************************************/
 108 {
 109     if (pBufferNode != m_pCurrentBufferNode)
 110     {
 111         if ( m_pCurrentBufferNode == m_pRootBufferNode &&
 112              m_xSAXEventKeeperStatusChangeListener.is())
 113         {
 114             m_xSAXEventKeeperStatusChangeListener->collectionStatusChanged(sal_True);
 115         }
 116
 117         if (pBufferNode->getParent() == NULL)
 118         {
 119             m_pCurrentBufferNode->addChild(pBufferNode);
 120             pBufferNode->setParent(m_pCurrentBufferNode);
 121         }
 122
 123         m_pCurrentBufferNode = pBufferNode;
 124     }
 125 }
 126
 127 BufferNode* SAXEventKeeperImpl::addNewElementMarkBuffers()
 128 /****** SAXEventKeeperImpl/addNewElementMarkBuffers **************************
 129  *
 130  *   NAME
 131  *  addNewElementMarkBuffers -- add new ElementCollectors and new Blocker.
 132  *
 133  *   SYNOPSIS
 134  *  pBufferNode = addNewElementMarkBuffers( );
 135  *
 136  *   FUNCTION
 137  *  if there are new ElementCollector or new Blocker to be added, then
 138  *  connect all of them with the current BufferNode. In case of the
 139  *  current BufferNode doesn't exist, creates one.
 140  *  Clears up the new ElementCollector list and the new Blocker pointer.
 141  *
 142  *   INPUTS
 143  *  empty
 144  *
 145  *   RESULT
 146  *  pBufferNode - the BufferNode that has been connected with both new
 147  *                ElementCollectors and new Blocker.
 148  *
 149  *   AUTHOR
 150  *  Michael Mi
 151  *  Email: michael.mi@sun.com
 152  ******************************************************************************/
 153 {
 154     BufferNode* pBufferNode = NULL;
 155
 156     if (m_pNewBlocker || !m_vNewElementCollectors.empty() )
 157     {
 158         /*
 159          * When the current BufferNode is right pointing to the current
 160          * working element in the XMLDocumentWrapper component, then
 161          * no new BufferNode is needed to create.
 162          * This situation can only happen in the "Forwarding" mode.
 163          */
 164         if ( (m_pCurrentBufferNode != NULL) &&
 165              (m_xXMLDocument->isCurrent(m_pCurrentBufferNode->getXMLElement())))
 166         {
 167             pBufferNode = m_pCurrentBufferNode;
 168         }
 169         else
 170         {
 171             pBufferNode = new BufferNode(m_xXMLDocument->getCurrentElement());
 172         }
 173
 174         if (m_pNewBlocker != NULL)
 175         {
 176             pBufferNode->setBlocker(m_pNewBlocker);
 177
 178             /*
 179              * If no blocking before, then notify the status change listener that
 180              * the SAXEventKeeper has entered "blocking" status, during which, no
 181              * SAX events will be forwarded to the next document handler.
 182              */
 183             if (m_pCurrentBlockingBufferNode == NULL)
 184             {
 185                 m_pCurrentBlockingBufferNode = pBufferNode;
 186
 187                 if (m_xSAXEventKeeperStatusChangeListener.is())
 188                 {
 189                     m_xSAXEventKeeperStatusChangeListener->blockingStatusChanged(sal_True);
 190                 }
 191             }
 192
 193             m_pNewBlocker = NULL;
 194         }
 195
 196         if (!m_vNewElementCollectors.empty())
 197         {
 198             std::vector< const ElementCollector* >::const_iterator ii = m_vNewElementCollectors.begin();
 199
 200             for( ; ii != m_vNewElementCollectors.end(); ++ii )
 201             {
 202                 pBufferNode->addElementCollector(*ii);
 203             }
 204
 205             m_vNewElementCollectors.clear();
 206         }
 207     }
 208
 209     return pBufferNode;
 210 }
 211
 212 ElementMark* SAXEventKeeperImpl::findElementMarkBuffer(sal_Int32 nId) const
 213 /****** SAXEventKeeperImpl/findElementMarkBuffer *****************************
 214  *
 215  *   NAME
 216  *  findElementMarkBuffer -- finds an ElementMark.
 217  *
 218  *   SYNOPSIS
 219  *  pElementMark = findElementMarkBuffer( nId );
 220  *
 221  *   FUNCTION
 222  *  searches an ElementMark with the particular Id in the ElementMark
 223  *  list.
 224  *
 225  *   INPUTS
 226  *  nId - the Id of the ElementMark to be searched.
 227  *
 228  *   RESULT
 229  *  pElementMark - the ElementMark with the particular Id, or NULL when
 230  *                 no such Id exists.
 231  *
 232  *   AUTHOR
 233  *  Michael Mi
 234  *  Email: michael.mi@sun.com
 235  ******************************************************************************/
 236 {
 237     ElementMark* pElementMark = NULL;
 238
 239     std::vector< const ElementMark* >::const_iterator ii = m_vElementMarkBuffers.begin();
 240
 241     for( ; ii != m_vElementMarkBuffers.end(); ++ii )
 242     {
 243         if ( nId == (*ii)->getBufferId())
 244         {
 245             pElementMark = const_cast<ElementMark*>(*ii);
 246             break;
 247         }
 248     }
 249
 250     return pElementMark;
 251 }
 252
 253 void SAXEventKeeperImpl::removeElementMarkBuffer(sal_Int32 nId)
 254 /****** SAXEventKeeperImpl/removeElementMarkBuffer ***************************
 255  *
 256  *   NAME
 257  *  removeElementMarkBuffer -- removes an ElementMark
 258  *
 259  *   SYNOPSIS
 260  *  removeElementMarkBuffer( nId );
 261  *
 262  *   FUNCTION
 263  *  removes an ElementMark with the particular Id in the ElementMark list.
 264  *
 265  *   INPUTS
 266  *  nId - the Id of the ElementMark to be removed.
 267  *
 268  *   RESULT
 269  *  empty
 270  *
 271  *   AUTHOR
 272  *  Michael Mi
 273  *  Email: michael.mi@sun.com
 274  ******************************************************************************/
 275 {
 276     std::vector< const ElementMark* >::iterator ii = m_vElementMarkBuffers.begin();
 277
 278     for( ; ii != m_vElementMarkBuffers.end(); ++ii )
 279     {
 280         if ( nId == (*ii)->getBufferId())
 281         {
 282             /*
 283              * checks whether this ElementMark still in the new ElementCollect array
 284              */
 285             std::vector< const ElementCollector* >::iterator jj = m_vNewElementCollectors.begin();
 286             for( ; jj != m_vNewElementCollectors.end(); ++jj )
 287             {
 288                 if ((*ii) == (*jj))
 289                 {
 290                     m_vNewElementCollectors.erase(jj);
 291                     break;
 292                 }
 293             }
 294
 295             /*
 296              * checks whether this ElementMark is the new Blocker
 297              */
 298             if ((*ii) == m_pNewBlocker)
 299             {
 300                 m_pNewBlocker = NULL;
 301             }
 302
 303             /*
 304              * destroy the ElementMark
 305              */
 306             delete (*ii);
 307
 308             m_vElementMarkBuffers.erase( ii );
 309             break;
 310         }
 311     }
 312 }
 313
 314 OUString SAXEventKeeperImpl::printBufferNode(
 315     BufferNode* pBufferNode, sal_Int32 nIndent) const
 316 /****** SAXEventKeeperImpl/printBufferNode ***********************************
 317  *
 318  *   NAME
 319  *  printBufferNode -- retrieves the information of a BufferNode and its
 320  *  branch.
 321  *
 322  *   SYNOPSIS
 323  *  info = printBufferNode( pBufferNode, nIndent );
 324  *
 325  *   FUNCTION
 326  *  all retrieved information includes:
 327  *  1. whether it is the current BufferNode;
 328  *  2. whether it is the current blocking BufferNode;
 329  *  3. the name of the parent element;
 330  *  4. the name of this element;
 331  *  5. all ElementCollectors working on this BufferNode;
 332  *  6. the Blocker working on this BufferNode;
 333  *  7. all child BufferNodes' information.
 334  *
 335  *   INPUTS
 336  *  pBufferNode -   the BufferNode from where information will be retrieved.
 337  *  nIndent -   how many space characters prefixed before the output
 338  *              message.
 339  *
 340  *   RESULT
 341  *  info - the information string
 342  *
 343  *   AUTHOR
 344  *  Michael Mi
 345  *  Email: michael.mi@sun.com
 346  ******************************************************************************/
 347 {
 348     OUString rc;
 349
 350     for ( int i=0; i<nIndent; ++i )
 351     {
 352         rc += OUString( " " );
 353     }
 354
 355     if (pBufferNode == m_pCurrentBufferNode)
 356     {
 357         rc += OUString( "[%]" );
 358     }
 359
 360     if (pBufferNode == m_pCurrentBlockingBufferNode)
 361     {
 362         rc += OUString( "[B]" );
 363     }
 364
 365     rc += OUString( " " );
 366     rc += m_xXMLDocument->getNodeName(pBufferNode->getXMLElement());
 367
 368     BufferNode* pParent = const_cast<BufferNode*>(pBufferNode->getParent());
 369     if (pParent != NULL)
 370     {
 371         rc += OUString( "[" );
 372         rc += m_xXMLDocument->getNodeName(pParent->getXMLElement());
 373         rc += OUString( "]" );
 374     }
 375
 376     rc += OUString( ":EC=" );
 377     rc += pBufferNode->printChildren();
 378     rc += OUString( " BR=" );
 379
 380     ElementMark * pBlocker = pBufferNode->getBlocker();
 381     if (pBlocker != NULL)
 382     {
 383         rc += OUString::number( pBlocker->getBufferId() );
 384         rc += OUString( "(SecId=" );
 385         rc += OUString::number( pBlocker->getSecurityId() );
 386         rc += OUString( ")" );
 387         rc += OUString( " " );
 388     }
 389     rc += OUString( "\n" );
 390
 391     std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren();
 392     std::vector< const BufferNode* >::const_iterator jj = vChildren->begin();
 393     for( ; jj != vChildren->end(); ++jj )
 394     {
 395         rc += printBufferNode(const_cast<BufferNode *>(*jj), nIndent+4);
 396     }
 397
 398     delete vChildren;
 399
 400     return rc;
 401 }
 402
 403 cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > >
 404     SAXEventKeeperImpl::collectChildWorkingElement(BufferNode* pBufferNode)
 405 /****** SAXEventKeeperImpl/collectChildWorkingElement ************************
 406  *
 407  *   NAME
 408  *  collectChildWorkingElement -- collects a BufferNode's all child
 409  *  Elements.
 410  *
 411  *   SYNOPSIS
 412  *  list = collectChildWorkingElement( pBufferNode );
 413  *
 414  *   FUNCTION
 415  *  see NAME.
 416  *
 417  *   INPUTS
 418  *  pBufferNode - the BufferNode whose child Elements will be collected.
 419  *
 420  *   RESULT
 421  *  list - the child Elements list.
 422  *
 423  *   AUTHOR
 424  *  Michael Mi
 425  *  Email: michael.mi@sun.com
 426  ******************************************************************************/
 427 {
 428     std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren();
 429
 430     cssu::Sequence < cssu::Reference<
 431         cssxw::XXMLElementWrapper > > aChildrenCollection ( vChildren->size());
 432
 433     std::vector< const BufferNode* >::const_iterator ii = vChildren->begin();
 434
 435     sal_Int32 nIndex = 0;
 436     for( ; ii != vChildren->end(); ++ii )
 437     {
 438         aChildrenCollection[nIndex] = (*ii)->getXMLElement();
 439         nIndex++;
 440     }
 441
 442     delete vChildren;
 443
 444     return aChildrenCollection;
 445 }
 446
 447 void SAXEventKeeperImpl::smashBufferNode(
 448     BufferNode* pBufferNode, bool bClearRoot) const
 449 /****** SAXEventKeeperImpl/smashBufferNode ***********************************
 450  *
 451  *   NAME
 452  *  smashBufferNode -- removes a BufferNode along with its working
 453  *  element.
 454  *
 455  *   SYNOPSIS
 456  *  smashBufferNode( pBufferNode, bClearRoot );
 457  *
 458  *   FUNCTION
 459  *  removes the BufferNode's working element from the DOM document, while
 460  *  reserves all ancestor paths for its child BufferNodes.
 461  *  when any of the BufferNode's ancestor element is useless, removes it
 462  *  too.
 463  *  removes the BufferNode from the BufferNode tree.
 464  *
 465  *   INPUTS
 466  *  pBufferNode -   the BufferNode to be removed
 467  *  bClearRoot -    whether the root element also needs to be cleared up.
 468  *
 469  *   RESULT
 470  *  empty
 471  *
 472  *   NOTES
 473  *  when removeing a Blocker's BufferNode, the bClearRoot flag should be
 474  *  true. Because a Blocker can buffer many SAX events which are not used
 475  *  by any other ElementCollector or Blocker.
 476  *  When the bClearRoot is set to true, the root BufferNode will be first
 477  *  cleared, with a stop flag seting at the next Blocking BufferNode. This
 478  *  operation can delete all useless bufferred SAX events which are only
 479  *  needed by the Blocker to be deleted.
 480  *
 481  *   AUTHOR
 482  *  Michael Mi
 483  *  Email: michael.mi@sun.com
 484  ******************************************************************************/
 485 {
 486     if (!pBufferNode->hasAnything())
 487     {
 488         BufferNode* pParent = const_cast<BufferNode*>(pBufferNode->getParent());
 489
 490             /*
 491              * delete the XML data
 492              */
 493         if (pParent == m_pRootBufferNode)
 494         {
 495             bool bIsNotBlocking = (m_pCurrentBlockingBufferNode == NULL);
 496             bool bIsBlockInside = false;
 497             bool bIsBlockingAfterward = false;
 498
 499                 /*
 500                  * If this is a blocker, then remove any out-element data
 501                  * which caused by blocking. The removal process will stop
 502                  * at the next blokcer to avoid removing any useful data.
 503                  */
 504             if (bClearRoot)
 505             {
 506                 cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > >
 507                     aChildElements = collectChildWorkingElement(m_pRootBufferNode);
 508
 509                     /*
 510                      * the clearUselessData only clearup the content in the
 511                      * node, not the node itself.
 512                      */
 513                 m_xXMLDocument->clearUselessData(m_pRootBufferNode->getXMLElement(),
 514                     aChildElements,
 515                     bIsNotBlocking?(NULL):
 516                                    (m_pCurrentBlockingBufferNode->getXMLElement()));
 517
 518                     /*
 519                      * remove the node if it is empty, then if its parent is also
 520                      * empty, remove it, then if the next parent is also empty,
 521                      * remove it,..., until parent become null.
 522                      */
 523                 m_xXMLDocument->collapse( m_pRootBufferNode->getXMLElement() );
 524             }
 525
 526             /*
 527              * if blocking, check the relationship between this BufferNode and
 528              * the current blocking BufferNode.
 529              */
 530             if ( !bIsNotBlocking )
 531             {
 532                 /*
 533                  * the current blocking BufferNode is a descendant of this BufferNode.
 534                  */
 535                 bIsBlockInside = (NULL != pBufferNode->isAncestor(m_pCurrentBlockingBufferNode));
 536
 537                 /*
 538                  * the current blocking BufferNode locates behind this BufferNode in tree
 539                  * order.
 540                  */
 541                 bIsBlockingAfterward = pBufferNode->isPrevious(m_pCurrentBlockingBufferNode);
 542             }
 543
 544             /*
 545              * this BufferNode's working element needs to be deleted only when
 546              * 1. there is no blocking, or
 547              * 2. the current blocking BufferNode is a descendant of this BufferNode,
 548              *    (then in the BufferNode's working element, the useless data before the blocking
 549              *     element should be deleted.) or
 550              * 3. the current blocking BufferNode is locates behind this BufferNode in tree,
 551              *    (then the useless data between the blocking element and the working element
 552              *     should be deleted.).
 553              * Otherwise, this working element should not be deleted.
 554              */
 555             if ( bIsNotBlocking || bIsBlockInside || bIsBlockingAfterward )
 556             {
 557                 cssu::Sequence< cssu::Reference< cssxw::XXMLElementWrapper > >
 558                     aChildElements = collectChildWorkingElement(pBufferNode);
 559
 560                     /*
 561                      * the clearUselessData only clearup the content in the
 562                      * node, not the node itself.
 563                      */
 564                 m_xXMLDocument->clearUselessData(pBufferNode->getXMLElement(),
 565                     aChildElements,
 566                     bIsBlockInside?(m_pCurrentBlockingBufferNode->getXMLElement()):
 567                                (NULL));
 568
 569                     /*
 570                      * remove the node if it is empty, then if its parent is also
 571                      * empty, remove it, then if the next parent is also empty,
 572                      * remove it,..., until parent become null.
 573                      */
 574                 m_xXMLDocument->collapse( pBufferNode->getXMLElement() );
 575             }
 576         }
 577
 578         sal_Int32 nIndex = pParent->indexOfChild(pBufferNode);
 579
 580         std::vector< const BufferNode* >* vChildren = pBufferNode->getChildren();
 581         pParent->removeChild(pBufferNode);
 582         pBufferNode->setParent(NULL);
 583
 584         std::vector< const BufferNode * >::const_iterator ii = vChildren->begin();
 585         for( ; ii != vChildren->end(); ++ii )
 586         {
 587             const_cast<BufferNode *>(*ii)->setParent(pParent);
 588             pParent->addChild(*ii, nIndex);
 589             nIndex++;
 590         }
 591
 592         delete vChildren;
 593
 594         /*
 595          * delete the BufferNode
 596          */
 597         delete pBufferNode;
 598     }
 599 }
 600
 601 BufferNode* SAXEventKeeperImpl::findNextBlockingBufferNode(
 602     BufferNode* pStartBufferNode)
 603 /****** SAXEventKeeperImpl/findNextBlockingBufferNode ************************
 604  *
 605  *   NAME
 606  *  findNextBlockingBufferNode -- finds the next blocking BufferNode
 607  *  behind the particular BufferNode.
 608  *
 609  *   SYNOPSIS
 610  *  pBufferNode = findNextBlockingBufferNode( pStartBufferNode );
 611  *
 612  *   FUNCTION
 613  *  see NAME.
 614  *
 615  *   INPUTS
 616  *  pStartBufferNode - the BufferNode from where to search the next
 617  *                     blocking BufferNode.
 618  *
 619  *   RESULT
 620  *  pBufferNode - the next blocking BufferNode, or NULL if no such
 621  *                BufferNode exists.
 622  *
 623  *   AUTHOR
 624  *  Michael Mi
 625  *  Email: michael.mi@sun.com
 626  ******************************************************************************/
 627 {
 628     BufferNode* pNext = NULL;
 629
 630     if (pStartBufferNode != NULL)
 631     {
 632         pNext = pStartBufferNode;
 633
 634         while (NULL != (pNext = const_cast<BufferNode*>(pNext->getNextNodeByTreeOrder())))
 635         {
 636             if (pNext->getBlocker() != NULL)
 637             {
 638                 break;
 639             }
 640         }
 641     }
 642
 643     return pNext;
 644 }
 645
 646 void SAXEventKeeperImpl::diffuse(BufferNode* pBufferNode)
 647 /****** SAXEventKeeperImpl/diffuse *******************************************
 648  *
 649  *   NAME
 650  *  diffuse -- diffuse the notification.
 651  *
 652  *   SYNOPSIS
 653  *  diffuse( pBufferNode );
 654  *
 655  *   FUNCTION
 656  *  diffuse the collecting completion notification from the specific
 657  *  BufferNode along its parent link, until an ancestor which is not
 658  *  completely received is met.
 659  *
 660  *   INPUTS
 661  *  pBufferNode - the BufferNode from which the notification will be
 662  *                diffused.
 663  *
 664  *   RESULT
 665  *  empty
 666  *
 667  *   AUTHOR
 668  *  Michael Mi
 669  *  Email: michael.mi@sun.com
 670  ******************************************************************************/
 671 {
 672     BufferNode* pParent = pBufferNode;
 673
 674     while(pParent->isAllReceived())
 675     {
 676         pParent->elementCollectorNotify();
 677         pParent = const_cast<BufferNode*>(pParent->getParent());
 678     }
 679 }
 680
 681 void SAXEventKeeperImpl::releaseElementMarkBuffer()
 682 /****** SAXEventKeeperImpl/releaseElementMarkBuffer **************************
 683  *
 684  *   NAME
 685  *  releaseElementMarkBuffer -- releases useless ElementMarks
 686  *
 687  *   SYNOPSIS
 688  *  releaseElementMarkBuffer( );
 689  *
 690  *   FUNCTION
 691  *  releases each ElementMark in the releasing list
 692  *  m_vReleasedElementMarkBuffers.
 693  *  The operation differs between an ElementCollector and a Blocker.
 694  *
 695  *   INPUTS
 696  *  empty
 697  *
 698  *   RESULT
 699  *  empty
 700  *
 701  *   AUTHOR
 702  *  Michael Mi
 703  *  Email: michael.mi@sun.com
 704  ******************************************************************************/
 705 {
 706     m_bIsReleasing = true;
 707     while (!m_vReleasedElementMarkBuffers.empty())
 708     {
 709         std::vector< sal_Int32 >::iterator pId = m_vReleasedElementMarkBuffers.begin();
 710         sal_Int32 nId = *pId;
 711         m_vReleasedElementMarkBuffers.erase( pId );
 712
 713         ElementMark* pElementMark = findElementMarkBuffer(nId);
 714
 715         if (pElementMark != NULL)
 716         {
 717             if (cssxc::sax::ElementMarkType_ELEMENTCOLLECTOR
 718                 == pElementMark->getType())
 719             /*
 720              * it is a EC
 721              */
 722             {
 723                 ElementCollector* pElementCollector = static_cast<ElementCollector*>(pElementMark);
 724
 725                 cssxc::sax::ElementMarkPriority nPriority = pElementCollector->getPriority();
 726                 /*
 727                      * Delete the EC from the buffer node.
 728                      */
 729                 BufferNode* pBufferNode = pElementCollector->getBufferNode();
 730                 pBufferNode->removeElementCollector(pElementCollector);
 731
 732                 if ( nPriority == cssxc::sax::ElementMarkPriority_BEFOREMODIFY)
 733                 {
 734                     pBufferNode->notifyBranch();
 735                 }
 736
 737                 /*
 738                  * delete the ElementMark
 739                  */
 740                 pElementCollector = NULL;
 741                 pElementMark = NULL;
 742                 removeElementMarkBuffer(nId);
 743
 744                 /*
 745                  * delete the BufferNode
 746                  */
 747                 diffuse(pBufferNode);
 748                 smashBufferNode(pBufferNode, false);
 749             }
 750             else
 751             /*
 752              * it is a Blocker
 753              */
 754             {
 755                     /*
 756                      * Delete the TH from the buffer node.
 757                      */
 758                 BufferNode *pBufferNode = pElementMark->getBufferNode();
 759                 pBufferNode->setBlocker(NULL);
 760
 761                     /*
 762                      * If there is a following handler and no blocking now, then
 763                      * forward this event
 764                      */
 765                 if (m_pCurrentBlockingBufferNode == pBufferNode)
 766                 {
 767                         /*
 768                          * Before forwarding, the next blocking point needs to be
 769                          * found.
 770                          */
 771                     m_pCurrentBlockingBufferNode = findNextBlockingBufferNode(pBufferNode);
 772
 773                         /*
 774                          * Forward the blocked events between these two STHs.
 775                          */
 776                            if (m_xNextHandler.is())
 777                            {
 778                                BufferNode* pTempCurrentBufferNode = m_pCurrentBufferNode;
 779                                BufferNode* pTempCurrentBlockingBufferNode = m_pCurrentBlockingBufferNode;
 780
 781                                m_pCurrentBufferNode = pBufferNode;
 782                                m_pCurrentBlockingBufferNode = NULL;
 783
 784                         m_bIsForwarding = true;
 785
 786                         m_xXMLDocument->generateSAXEvents(
 787                             m_xNextHandler,
 788                             this,
 789                             pBufferNode->getXMLElement(),
 790                             (pTempCurrentBlockingBufferNode == NULL)?NULL:(pTempCurrentBlockingBufferNode->getXMLElement()));
 791
 792                         m_bIsForwarding = false;
 793
 794                         m_pCurrentBufferNode = pTempCurrentBufferNode;
 795                         if (m_pCurrentBlockingBufferNode == NULL)
 796                         {
 797                             m_pCurrentBlockingBufferNode = pTempCurrentBlockingBufferNode;
 798                         }
 799                     }
 800
 801                     if (m_pCurrentBlockingBufferNode == NULL &&
 802                         m_xSAXEventKeeperStatusChangeListener.is())
 803                     {
 804                         m_xSAXEventKeeperStatusChangeListener->blockingStatusChanged(sal_False);
 805                     }
 806                 }
 807
 808                 /*
 809                  * delete the ElementMark
 810                  */
 811                 pElementMark = NULL;
 812                 removeElementMarkBuffer(nId);
 813
 814                 /*
 815                  * delete the BufferNode
 816                  */
 817                 diffuse(pBufferNode);
 818                 smashBufferNode(pBufferNode, true);
 819             }
 820         }
 821     }
 822
 823     m_bIsReleasing = false;
 824
 825     if (!m_pRootBufferNode->hasAnything() &&
 826         !m_pRootBufferNode->hasChildren() &&
 827         m_xSAXEventKeeperStatusChangeListener.is())
 828     {
 829         m_xSAXEventKeeperStatusChangeListener->bufferStatusChanged(sal_True);
 830     }
 831 }
 832
 833 void SAXEventKeeperImpl::markElementMarkBuffer(sal_Int32 nId)
 834 /****** SAXEventKeeperImpl/markElementMarkBuffer *****************************
 835  *
 836  *   NAME
 837  *  markElementMarkBuffer -- marks an ElementMark to be released
 838  *
 839  *   SYNOPSIS
 840  *  markElementMarkBuffer( nId );
 841  *
 842  *   FUNCTION
 843  *  puts the ElementMark with the particular Id into the releasing list,
 844  *  checks whether the releasing process is running, if not then launch
 845  *  this process.
 846  *
 847  *   INPUTS
 848  *  nId - the Id of the ElementMark which will be released
 849  *
 850  *   RESULT
 851  *  empty
 852  *
 853  *   AUTHOR
 854  *  Michael Mi
 855  *  Email: michael.mi@sun.com
 856  ******************************************************************************/
 857 {
 858     m_vReleasedElementMarkBuffers.push_back( nId );
 859     if ( !m_bIsReleasing )
 860     {
 861         releaseElementMarkBuffer();
 862     }
 863 }
 864
 865 sal_Int32 SAXEventKeeperImpl::createElementCollector(
 866     sal_Int32 nSecurityId,
 867     cssxc::sax::ElementMarkPriority nPriority,
 868     bool bModifyElement,
 869     const cssu::Reference< cssxc::sax::XReferenceResolvedListener >& xReferenceResolvedListener)
 870 /****** SAXEventKeeperImpl/createElementCollector ****************************
 871  *
 872  *   NAME
 873  *  createElementCollector -- creates a new ElementCollector on the
 874  *  incoming element.
 875  *
 876  *   SYNOPSIS
 877  *  nId = createElementCollector( nSecurityId, nPriority,
 878  *                               bModifyElement,
 879  *                               xReferenceResolvedListener );
 880  *
 881  *   FUNCTION
 882  *  allocs a new Id, then create an ElementCollector with this Id value.
 883  *  Add the new created ElementCollector to the new ElementCollecotor list.
 884  *
 885  *   INPUTS
 886  *  nSecurityId -   the security Id of the new ElementCollector
 887  *  nPriority -     the prirority of the new ElementCollector
 888  *  bModifyElement -whether this BufferNode will modify the content of
 889  *                  the corresponding element it works on
 890  *  xReferenceResolvedListener - the listener for the new ElementCollector.
 891  *
 892  *   RESULT
 893  *  nId - the Id of the new ElementCollector
 894  *
 895  *   AUTHOR
 896  *  Michael Mi
 897  *  Email: michael.mi@sun.com
 898  ******************************************************************************/
 899 {
 900     sal_Int32 nId = m_nNextElementMarkId;
 901     m_nNextElementMarkId ++;
 902
 903     ElementCollector* pElementCollector
 904         = new ElementCollector(
 905             nSecurityId,
 906             nId,
 907             nPriority,
 908             bModifyElement,
 909             xReferenceResolvedListener);
 910
 911     m_vElementMarkBuffers.push_back( pElementCollector );
 912
 913         /*
 914          * All the new EC to initial EC array.
 915          */
 916     m_vNewElementCollectors.push_back( pElementCollector );
 917
 918     return nId;
 919 }
 920
 921
 922 sal_Int32 SAXEventKeeperImpl::createBlocker(sal_Int32 nSecurityId)
 923 /****** SAXEventKeeperImpl/createBlocker *************************************
 924  *
 925  *   NAME
 926  *  createBlocker -- creates a new Blocker on the incoming element.
 927  *
 928  *   SYNOPSIS
 929  *  nId = createBlocker( nSecurityId );
 930  *
 931  *   FUNCTION
 932  *  see NAME.
 933  *
 934  *   INPUTS
 935  *  nSecurityId -   the security Id of the new Blocker
 936  *
 937  *   RESULT
 938  *  nId - the Id of the new Blocker
 939  *
 940  *   AUTHOR
 941  *  Michael Mi
 942  *  Email: michael.mi@sun.com
 943  ******************************************************************************/
 944 {
 945     sal_Int32 nId = m_nNextElementMarkId;
 946     m_nNextElementMarkId ++;
 947
 948     OSL_ASSERT(m_pNewBlocker == NULL);
 949
 950     m_pNewBlocker = new ElementMark(nSecurityId, nId);
 951     m_vElementMarkBuffers.push_back( m_pNewBlocker );
 952
 953     return nId;
 954 }
 955
 956 /* XSAXEventKeeper */
 957 sal_Int32 SAL_CALL SAXEventKeeperImpl::addElementCollector(  )
 958     throw (cssu::RuntimeException, std::exception)
 959 {
 960     return createElementCollector(
 961         cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID,
 962         cssxc::sax::ElementMarkPriority_AFTERMODIFY,
 963         false,
 964         NULL);
 965 }
 966
 967 void SAL_CALL SAXEventKeeperImpl::removeElementCollector( sal_Int32 id )
 968     throw (cssu::RuntimeException, std::exception)
 969 {
 970     markElementMarkBuffer(id);
 971 }
 972
 973 sal_Int32 SAL_CALL SAXEventKeeperImpl::addBlocker(  )
 974     throw (cssu::RuntimeException, std::exception)
 975 {
 976     return createBlocker(cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID);
 977 }
 978
 979 void SAL_CALL SAXEventKeeperImpl::removeBlocker( sal_Int32 id )
 980     throw (cssu::RuntimeException, std::exception)
 981 {
 982     markElementMarkBuffer(id);
 983 }
 984
 985 sal_Bool SAL_CALL SAXEventKeeperImpl::isBlocking(  )
 986     throw (cssu::RuntimeException, std::exception)
 987 {
 988     return (m_pCurrentBlockingBufferNode != NULL);
 989 }
 990
 991 cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL
 992     SAXEventKeeperImpl::getElement( sal_Int32 id )
 993     throw (cssu::RuntimeException, std::exception)
 994 {
 995     cssu::Reference< cssxw::XXMLElementWrapper > rc;
 996
 997     ElementMark* pElementMark = findElementMarkBuffer(id);
 998     if (pElementMark != NULL)
 999     {
1000         rc = pElementMark->getBufferNode()->getXMLElement();
1001     }
1002
1003     return rc;
1004 }
1005
1006 void SAL_CALL SAXEventKeeperImpl::setElement(
1007     sal_Int32 id,
1008     const cssu::Reference< cssxw::XXMLElementWrapper >& aElement )
1009     throw (cssu::RuntimeException, std::exception)
1010 {
1011     if (aElement.is())
1012     {
1013         m_xXMLDocument->rebuildIDLink(aElement);
1014
1015         ElementMark* pElementMark = findElementMarkBuffer(id);
1016
1017         if (pElementMark != NULL)
1018         {
1019             BufferNode* pBufferNode = pElementMark->getBufferNode();
1020             if (pBufferNode != NULL)
1021             {
1022                     bool bIsCurrent = m_xXMLDocument->isCurrent(pBufferNode->getXMLElement());
1023                 pBufferNode->setXMLElement(aElement);
1024
1025                 if (bIsCurrent)
1026                 {
1027                     m_xXMLDocument->setCurrentElement(aElement);
1028                 }
1029             }
1030         }
1031     }
1032     else
1033     {
1034         removeElementCollector( id );
1035     }
1036 }
1037
1038 cssu::Reference< cssxs::XDocumentHandler > SAL_CALL SAXEventKeeperImpl::setNextHandler(
1039     const cssu::Reference< cssxs::XDocumentHandler >& xNewHandler )
1040     throw (cssu::RuntimeException, std::exception)
1041 {
1042     cssu::Reference< cssxs::XDocumentHandler > xOldHandler = m_xNextHandler;
1043
1044     m_xNextHandler = xNewHandler;
1045     return xOldHandler;
1046 }
1047
1048 OUString SAL_CALL SAXEventKeeperImpl::printBufferNodeTree()
1049     throw (cssu::RuntimeException, std::exception)
1050 {
1051     OUString rc;
1052
1053     rc += OUString( "ElementMarkBuffers: size = " );
1054     rc += OUString::number(m_vElementMarkBuffers.size());
1055     rc += OUString( "\nCurrentBufferNode: " );
1056     rc += m_xXMLDocument->getNodeName(m_pCurrentBufferNode->getXMLElement());
1057     rc += OUString( "\n" );
1058     rc += printBufferNode(m_pRootBufferNode, 0);
1059
1060     return rc;
1061 }
1062
1063 cssu::Reference< cssxw::XXMLElementWrapper > SAL_CALL SAXEventKeeperImpl::getCurrentBlockingNode()
1064     throw (cssu::RuntimeException, std::exception)
1065 {
1066     cssu::Reference< cssxw::XXMLElementWrapper > rc;
1067
1068     if (m_pCurrentBlockingBufferNode != NULL)
1069     {
1070         rc = m_pCurrentBlockingBufferNode->getXMLElement();
1071     }
1072
1073     return rc;
1074 }
1075
1076 /* XSecuritySAXEventKeeper */
1077 sal_Int32 SAL_CALL SAXEventKeeperImpl::addSecurityElementCollector(
1078     cssxc::sax::ElementMarkPriority priority,
1079     sal_Bool modifyElement )
1080     throw (cssu::RuntimeException, std::exception)
1081 {
1082     return createElementCollector(
1083         cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID,
1084         priority,
1085         modifyElement,
1086         NULL);
1087 }
1088
1089 sal_Int32 SAL_CALL SAXEventKeeperImpl::cloneElementCollector(
1090     sal_Int32 referenceId,
1091     cssxc::sax::ElementMarkPriority priority )
1092     throw (cssu::RuntimeException, std::exception)
1093 {
1094     sal_Int32 nId = -1;
1095
1096     ElementCollector* pElementCollector = static_cast<ElementCollector*>(findElementMarkBuffer(referenceId));
1097     if (pElementCollector != NULL)
1098     {
1099         nId = m_nNextElementMarkId;
1100         m_nNextElementMarkId ++;
1101
1102         ElementCollector* pClonedOne
1103             = pElementCollector->clone(nId, priority);
1104
1105             /*
1106              * add this EC into the security data buffer array.
1107              */
1108         m_vElementMarkBuffers.push_back(pClonedOne);
1109
1110             /*
1111              * If the reference EC is still in initial EC array, add
1112              * this cloned one into the initial EC array too.
1113              */
1114             if (pElementCollector->getBufferNode() == NULL)
1115         {
1116             m_vNewElementCollectors.push_back(pClonedOne);
1117         }
1118     }
1119
1120     return nId;
1121 }
1122
1123 void SAL_CALL SAXEventKeeperImpl::setSecurityId( sal_Int32 id, sal_Int32 securityId )
1124     throw (cssu::RuntimeException, std::exception)
1125 {
1126     ElementMark* pElementMark = findElementMarkBuffer(id);
1127     if (pElementMark != NULL)
1128     {
1129         pElementMark->setSecurityId(securityId);
1130     }
1131 }
1132
1133
1134 /* XReferenceResolvedBroadcaster */
1135 void SAL_CALL SAXEventKeeperImpl::addReferenceResolvedListener(
1136     sal_Int32 referenceId,
1137     const cssu::Reference< cssxc::sax::XReferenceResolvedListener >& listener )
1138     throw (cssu::RuntimeException, std::exception)
1139 {
1140     ElementCollector* pElementCollector = static_cast<ElementCollector*>(findElementMarkBuffer(referenceId));
1141     if (pElementCollector != NULL)
1142     {
1143         pElementCollector->setReferenceResolvedListener(listener);
1144     }
1145 }
1146
1147 void SAL_CALL SAXEventKeeperImpl::removeReferenceResolvedListener(
1148     sal_Int32 /*referenceId*/,
1149     const cssu::Reference< cssxc::sax::XReferenceResolvedListener >&)
1150     throw (cssu::RuntimeException, std::exception)
1151 {
1152 }
1153
1154 /* XSAXEventKeeperStatusChangeBroadcaster */
1155 void SAL_CALL SAXEventKeeperImpl::addSAXEventKeeperStatusChangeListener(
1156     const cssu::Reference< cssxc::sax::XSAXEventKeeperStatusChangeListener >& listener )
1157     throw (cssu::RuntimeException, std::exception)
1158 {
1159     m_xSAXEventKeeperStatusChangeListener = listener;
1160 }
1161
1162 void SAL_CALL SAXEventKeeperImpl::removeSAXEventKeeperStatusChangeListener(
1163     const cssu::Reference< cssxc::sax::XSAXEventKeeperStatusChangeListener >&)
1164     throw (cssu::RuntimeException, std::exception)
1165 {
1166 }
1167
1168 /* XDocumentHandler */
1169 void SAL_CALL SAXEventKeeperImpl::startDocument(  )
1170     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1171 {
1172     if ( m_xNextHandler.is())
1173     {
1174         m_xNextHandler->startDocument();
1175     }
1176 }
1177
1178 void SAL_CALL SAXEventKeeperImpl::endDocument(  )
1179     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1180 {
1181     if ( m_xNextHandler.is())
1182     {
1183         m_xNextHandler->endDocument();
1184     }
1185 }
1186
1187 void SAL_CALL SAXEventKeeperImpl::startElement(
1188     const OUString& aName,
1189     const cssu::Reference< cssxs::XAttributeList >& xAttribs )
1190     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1191 {
1192         /*
1193          * If there is a following handler and no blocking now, then
1194          * forward this event
1195          */
1196     if ((m_pCurrentBlockingBufferNode == NULL) &&
1197         (m_xNextHandler.is()) &&
1198         (!m_bIsForwarding) &&
1199         (m_pNewBlocker == NULL))
1200     {
1201         m_xNextHandler->startElement(aName, xAttribs);
1202     }
1203
1204         /*
1205          * If not forwarding, buffer this startElement.
1206          */
1207            if (!m_bIsForwarding)
1208            {
1209     #ifndef _USECOMPRESSEDDOCUMENTHANDLER
1210         m_xDocumentHandler->startElement(aName, xAttribs);
1211     #else
1212         sal_Int32 nLength = xAttribs->getLength();
1213         cssu::Sequence< cssxcsax::XMLAttribute > aAttributes (nLength);
1214
1215         for ( int i = 0; i<nLength; ++i )
1216         {
1217             aAttributes[i].sName = xAttribs->getNameByIndex((short)i);
1218             aAttributes[i].sValue =xAttribs->getValueByIndex((short)i);
1219         }
1220
1221         m_xCompressedDocumentHandler->compressedStartElement(aName, aAttributes);
1222     #endif
1223
1224     }
1225
1226     BufferNode* pBufferNode = addNewElementMarkBuffers();
1227         if (pBufferNode != NULL)
1228         {
1229         setCurrentBufferNode(pBufferNode);
1230     }
1231 }
1232
1233 void SAL_CALL SAXEventKeeperImpl::endElement( const OUString& aName )
1234     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1235 {
1236         bool bIsCurrent = m_xXMLDocument->isCurrent(m_pCurrentBufferNode->getXMLElement());
1237
1238         /*
1239          * If there is a following handler and no blocking now, then
1240          * forward this event
1241          */
1242     if ((m_pCurrentBlockingBufferNode == NULL) &&
1243         (m_xNextHandler.is()) &&
1244         (!m_bIsForwarding))
1245     {
1246         m_xNextHandler->endElement(aName);
1247     }
1248
1249     if ((m_pCurrentBlockingBufferNode != NULL) ||
1250         (m_pCurrentBufferNode != m_pRootBufferNode) ||
1251         (!m_xXMLDocument->isCurrentElementEmpty()))
1252     {
1253             if (!m_bIsForwarding)
1254             {
1255         #ifndef _USECOMPRESSEDDOCUMENTHANDLER
1256             m_xDocumentHandler->endElement(aName);
1257         #else
1258             m_xCompressedDocumentHandler->compressedEndElement(aName);
1259         #endif
1260         }
1261
1262         /*
1263         * If the current buffer node has not notified yet, and
1264         * the current buffer node is waiting for the current element,
1265         * then let it notify.
1266         */
1267            if (bIsCurrent && (m_pCurrentBufferNode != m_pRootBufferNode))
1268         {
1269             BufferNode* pOldCurrentBufferNode = m_pCurrentBufferNode;
1270             m_pCurrentBufferNode = const_cast<BufferNode*>(m_pCurrentBufferNode->getParent());
1271
1272             pOldCurrentBufferNode->setReceivedAll();
1273
1274             if ((m_pCurrentBufferNode == m_pRootBufferNode) &&
1275                 m_xSAXEventKeeperStatusChangeListener.is())
1276             {
1277                 m_xSAXEventKeeperStatusChangeListener->collectionStatusChanged(sal_False);
1278             }
1279         }
1280     }
1281     else
1282     {
1283         if (!m_bIsForwarding)
1284         {
1285             m_xXMLDocument->removeCurrentElement();
1286         }
1287     }
1288 }
1289
1290 void SAL_CALL SAXEventKeeperImpl::characters( const OUString& aChars )
1291     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1292 {
1293     if (!m_bIsForwarding)
1294     {
1295         if ((m_pCurrentBlockingBufferNode == NULL) && m_xNextHandler.is())
1296         {
1297             m_xNextHandler->characters(aChars);
1298         }
1299
1300         if ((m_pCurrentBlockingBufferNode != NULL) ||
1301             (m_pCurrentBufferNode != m_pRootBufferNode))
1302         {
1303         #ifndef _USECOMPRESSEDDOCUMENTHANDLER
1304                 m_xDocumentHandler->characters(aChars);
1305         #else
1306             m_xCompressedDocumentHandler->compressedCharacters(aChars);
1307         #endif
1308             }
1309         }
1310 }
1311
1312 void SAL_CALL SAXEventKeeperImpl::ignorableWhitespace( const OUString& aWhitespaces )
1313     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1314 {
1315     characters( aWhitespaces );
1316 }
1317
1318 void SAL_CALL SAXEventKeeperImpl::processingInstruction(
1319     const OUString& aTarget, const OUString& aData )
1320     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1321 {
1322     if (!m_bIsForwarding)
1323     {
1324         if ((m_pCurrentBlockingBufferNode == NULL) && m_xNextHandler.is())
1325         {
1326             m_xNextHandler->processingInstruction(aTarget, aData);
1327         }
1328
1329         if ((m_pCurrentBlockingBufferNode != NULL) ||
1330             (m_pCurrentBufferNode != m_pRootBufferNode))
1331         {
1332         #ifndef _USECOMPRESSEDDOCUMENTHANDLER
1333             m_xDocumentHandler->processingInstruction(aTarget, aData);
1334         #else
1335             m_xCompressedDocumentHandler->compressedProcessingInstruction(aTarget, aData);
1336         #endif
1337             }
1338         }
1339 }
1340
1341 void SAL_CALL SAXEventKeeperImpl::setDocumentLocator( const cssu::Reference< cssxs::XLocator >&)
1342     throw (cssxs::SAXException, cssu::RuntimeException, std::exception)
1343 {
1344 }
1345
1346 /* XInitialization */
1347 void SAL_CALL SAXEventKeeperImpl::initialize( const cssu::Sequence< cssu::Any >& aArguments )
1348     throw (cssu::Exception, cssu::RuntimeException, std::exception)
1349 {
1350     OSL_ASSERT(aArguments.getLength() == 1);
1351
1352     aArguments[0] >>= m_xXMLDocument;
1353     m_xDocumentHandler = cssu::Reference< cssxs::XDocumentHandler >(
1354         m_xXMLDocument, cssu::UNO_QUERY );
1355     m_xCompressedDocumentHandler = cssu::Reference< cssxcsax::XCompressedDocumentHandler >(
1356         m_xXMLDocument, cssu::UNO_QUERY );
1357
1358     m_pRootBufferNode = new BufferNode(m_xXMLDocument->getCurrentElement());
1359     m_pCurrentBufferNode = m_pRootBufferNode;
1360 }
1361
1362 OUString SAXEventKeeperImpl_getImplementationName ()
1363     throw (cssu::RuntimeException)
1364 {
1365     return OUString ( IMPLEMENTATION_NAME );
1366 }
1367
1368 cssu::Sequence< OUString > SAL_CALL SAXEventKeeperImpl_getSupportedServiceNames(  )
1369     throw (cssu::RuntimeException)
1370 {
1371     cssu::Sequence < OUString > aRet(1);
1372     OUString* pArray = aRet.getArray();
1373     pArray[0] = "com.sun.star.xml.crypto.sax.SAXEventKeeper";
1374     return aRet;
1375 }
1376
1377 cssu::Reference< cssu::XInterface > SAL_CALL SAXEventKeeperImpl_createInstance(
1378     const cssu::Reference< cssl::XMultiServiceFactory > &)
1379     throw( cssu::Exception )
1380 {
1381     return (cppu::OWeakObject*) new SAXEventKeeperImpl();
1382 }
1383
1384 /* XServiceInfo */
1385 OUString SAL_CALL SAXEventKeeperImpl::getImplementationName(  )
1386     throw (cssu::RuntimeException, std::exception)
1387 {
1388     return SAXEventKeeperImpl_getImplementationName();
1389 }
1390
1391 sal_Bool SAL_CALL SAXEventKeeperImpl::supportsService( const OUString& rServiceName )
1392     throw (cssu::RuntimeException, std::exception)
1393 {
1394     return cppu::supportsService(this, rServiceName);
1395 }
1396
1397 cssu::Sequence< OUString > SAL_CALL SAXEventKeeperImpl::getSupportedServiceNames(  )
1398     throw (cssu::RuntimeException, std::exception)
1399 {
1400     return SAXEventKeeperImpl_getSupportedServiceNames();
1401 }
1402
1403 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */