xmlsecurity/source/framework/buffernode.cxx

   1 /*************************************************************************
   2  *
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * Copyright 2000, 2010 Oracle and/or its affiliates.
   6  *
   7  * OpenOffice.org - a multi-platform office productivity suite
   8  *
   9  * This file is part of OpenOffice.org.
  10  *
  11  * OpenOffice.org is free software: you can redistribute it and/or modify
  12  * it under the terms of the GNU Lesser General Public License version 3
  13  * only, as published by the Free Software Foundation.
  14  *
  15  * OpenOffice.org is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU Lesser General Public License version 3 for more details
  19  * (a copy is included in the LICENSE file that accompanied this code).
  20  *
  21  * You should have received a copy of the GNU Lesser General Public License
  22  * version 3 along with OpenOffice.org.  If not, see
  23  * <http://www.openoffice.org/license.html>
  24  * for a copy of the LGPLv3 License.
  25  *
  26  ************************************************************************/
  27
  28 // MARKER(update_precomp.py): autogen include statement, do not remove
  29 #include "precompiled_xmlsecurity.hxx"
  30
  31 #include "elementmark.hxx"
  32 #include "elementcollector.hxx"
  33 #include "buffernode.hxx"
  34 #include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp>
  35
  36 namespace cssu = com::sun::star::uno;
  37 namespace cssxw = com::sun::star::xml::wrapper;
  38 namespace cssxc = com::sun::star::xml::crypto;
  39
  40 BufferNode::BufferNode( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement )
  41     :m_pParent(NULL),
  42      m_pBlocker(NULL),
  43      m_bAllReceived(false),
  44      m_xXMLElement(xXMLElement)
  45 {
  46 }
  47
  48 bool BufferNode::isECOfBeforeModifyIncluded(sal_Int32 nIgnoredSecurityId) const
  49 /****** BufferNode/isECOfBeforeModifyIncluded ********************************
  50  *
  51  *   NAME
  52  *  isECOfBeforeModifyIncluded -- checks whether there is some
  53  *  ElementCollector on this BufferNode, that has BEFORE-MODIFY priority.
  54  *
  55  *   SYNOPSIS
  56  *  bExist = isECOfBeforeModifyIncluded(nIgnoredSecurityId);
  57  *
  58  *   FUNCTION
  59  *  checks each ElementCollector on this BufferNode, if all following
  60  *  conditions are satisfied, then returns true:
  61  *  1. the ElementCollector's priority is BEFOREMODIFY;
  62  *  2. the ElementCollector's securityId can't be ignored.
  63  *  otherwise, returns false.
  64  *
  65  *   INPUTS
  66  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
  67  *                          to UNDEFINEDSECURITYID, then no security Id
  68  *                          will be ignored.
  69  *
  70  *   RESULT
  71  *  bExist - true if a match found, false otherwise
  72  *
  73  *   HISTORY
  74  *  05.01.2004 -    implemented
  75  *
  76  *   AUTHOR
  77  *  Michael Mi
  78  *  Email: michael.mi@sun.com
  79  ******************************************************************************/
  80 {
  81     bool rc = false;
  82     std::vector< const ElementCollector* >::const_iterator ii = m_vElementCollectors.begin();
  83
  84     for( ; ii != m_vElementCollectors.end() ; ++ii )
  85     {
  86         ElementCollector* pElementCollector = (ElementCollector*)*ii;
  87
  88         if ((nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
  89              pElementCollector->getSecurityId() != nIgnoredSecurityId) &&
  90             (pElementCollector->getPriority() == cssxc::sax::ElementMarkPriority_BEFOREMODIFY))
  91         {
  92             rc = true;
  93             break;
  94         }
  95     }
  96
  97     return rc;
  98 }
  99
 100 void BufferNode::setReceivedAll()
 101 /****** BufferNode/setReceiveAll *********************************************
 102  *
 103  *   NAME
 104  *  setReceivedAll -- indicates that the element in this BufferNode has
 105  *  been compeletely bufferred.
 106  *
 107  *   SYNOPSIS
 108  *  setReceivedAll();
 109  *
 110  *   FUNCTION
 111  *  sets the all-received flag and launches ElementCollector's notify
 112  *  process.
 113  *
 114  *   INPUTS
 115  *  empty
 116  *
 117  *   RESULT
 118  *  empty
 119  *
 120  *   HISTORY
 121  *  05.01.2004 -    implemented
 122  *
 123  *   AUTHOR
 124  *  Michael Mi
 125  *  Email: michael.mi@sun.com
 126  ******************************************************************************/
 127 {
 128     m_bAllReceived = true;
 129     elementCollectorNotify();
 130 }
 131
 132 bool BufferNode::isAllReceived() const
 133 {
 134     return m_bAllReceived;
 135 }
 136
 137 void BufferNode::addElementCollector(const ElementCollector* pElementCollector)
 138 /****** BufferNode/addElementCollector ***************************************
 139  *
 140  *   NAME
 141  *  addElementCollector -- adds a new ElementCollector to this BufferNode.
 142  *
 143  *   SYNOPSIS
 144  *  addElementCollector(pElementCollector);
 145  *
 146  *   FUNCTION
 147  *  see NAME
 148  *
 149  *   INPUTS
 150  *  pElementCollector - the ElementCollector to be added
 151  *
 152  *   RESULT
 153  *  empty
 154  *
 155  *   HISTORY
 156  *  05.01.2004 -    implemented
 157  *
 158  *   AUTHOR
 159  *  Michael Mi
 160  *  Email: michael.mi@sun.com
 161  ******************************************************************************/
 162 {
 163     m_vElementCollectors.push_back( pElementCollector );
 164     ((ElementCollector*)pElementCollector)->setBufferNode(this);
 165 }
 166
 167 void BufferNode::removeElementCollector(const ElementCollector* pElementCollector)
 168 /****** BufferNode/removeElementCollector ************************************
 169  *
 170  *   NAME
 171  *  removeElementCollector -- removes an ElementCollector from this
 172  *  BufferNode.
 173  *
 174  *   SYNOPSIS
 175  *  removeElementCollector(pElementCollector);
 176  *
 177  *   FUNCTION
 178  *  see NAME
 179  *
 180  *   INPUTS
 181  *  pElementCollector - the ElementCollector to be removed
 182  *
 183  *   RESULT
 184  *  empty
 185  *
 186  *   HISTORY
 187  *  05.01.2004 -    implemented
 188  *
 189  *   AUTHOR
 190  *  Michael Mi
 191  *  Email: michael.mi@sun.com
 192  ******************************************************************************/
 193 {
 194     std::vector< const ElementCollector* >::iterator ii = m_vElementCollectors.begin();
 195
 196     for( ; ii != m_vElementCollectors.end() ; ++ii )
 197     {
 198         if( *ii == pElementCollector )
 199         {
 200             m_vElementCollectors.erase( ii );
 201             ((ElementCollector*)pElementCollector)->setBufferNode(NULL);
 202             break;
 203         }
 204     }
 205 }
 206
 207 ElementMark* BufferNode::getBlocker() const
 208 {
 209     return m_pBlocker;
 210 }
 211
 212 void BufferNode::setBlocker(const ElementMark* pBlocker)
 213 /****** BufferNode/setBlocker ************************************************
 214  *
 215  *   NAME
 216  *  setBlocker -- adds a blocker to this BufferNode.
 217  *
 218  *   SYNOPSIS
 219  *  setBlocker(pBlocker);
 220  *
 221  *   FUNCTION
 222  *  see NAME
 223  *
 224  *   INPUTS
 225  *  pBlocker - the new blocker to be attached
 226  *
 227  *   RESULT
 228  *  empty
 229  *
 230  *   NOTES
 231  *  Because there is only one blocker permited for a BufferNode, so the
 232  *  old blocker on this BufferNode, if there is one, will be overcasted.
 233  *
 234  *   HISTORY
 235  *  05.01.2004 -    implemented
 236  *
 237  *   AUTHOR
 238  *  Michael Mi
 239  *  Email: michael.mi@sun.com
 240  ******************************************************************************/
 241 {
 242     OSL_ASSERT(!(m_pBlocker != NULL && pBlocker != NULL));
 243
 244     m_pBlocker = (ElementMark*)pBlocker;
 245     if (m_pBlocker != NULL)
 246     {
 247         m_pBlocker->setBufferNode(this);
 248     }
 249 }
 250
 251 rtl::OUString BufferNode::printChildren() const
 252 /****** BufferNode/printChildren *********************************************
 253  *
 254  *   NAME
 255  *  printChildren -- prints children information into a string.
 256  *
 257  *   SYNOPSIS
 258  *  result = printChildren();
 259  *
 260  *   FUNCTION
 261  *  see NAME
 262  *
 263  *   INPUTS
 264  *  empty
 265  *
 266  *   RESULT
 267  *  result - the information string
 268  *
 269  *   HISTORY
 270  *  05.01.2004 -    implemented
 271  *
 272  *   AUTHOR
 273  *  Michael Mi
 274  *  Email: michael.mi@sun.com
 275  ******************************************************************************/
 276 {
 277     rtl::OUString rc;
 278     std::vector< const ElementCollector* >::const_iterator ii = m_vElementCollectors.begin();
 279
 280     for( ; ii != m_vElementCollectors.end() ; ++ii )
 281     {
 282         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BufID=" ));
 283         rc += rtl::OUString::valueOf((*ii)->getBufferId());
 284
 285         if (((ElementCollector*)(*ii))->getModify())
 286         {
 287             rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[M]" ));
 288         }
 289
 290         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ",Pri=" ));
 291
 292         switch (((ElementCollector*)(*ii))->getPriority())
 293         {
 294             case cssxc::sax::ElementMarkPriority_BEFOREMODIFY:
 295                 rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BEFOREMODIFY" ));
 296                 break;
 297             case cssxc::sax::ElementMarkPriority_AFTERMODIFY:
 298                 rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "AFTERMODIFY" ));
 299                 break;
 300             default:
 301                 rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UNKNOWN" ));
 302                 break;
 303         }
 304
 305         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "(" ));
 306         /*
 307         if (((ElementCollector*)(*ii))->isInternalNotificationSuppressed())
 308         {
 309             rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "*IN-Suppressed* " ));
 310         }
 311         */
 312         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SecID=" ));
 313         rc += rtl::OUString::valueOf(((ElementCollector*)(*ii))->getSecurityId());
 314         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ")" ));
 315         rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " ));
 316     }
 317
 318     return rc;
 319 }
 320
 321 bool BufferNode::hasAnything() const
 322 /****** BufferNode/hasAnything ***********************************************
 323  *
 324  *   NAME
 325  *  hasAnything -- checks whether there is any ElementCollector or blocker
 326  *  on this BufferNode.
 327  *
 328  *   SYNOPSIS
 329  *  bExist = hasAnything();
 330  *
 331  *   FUNCTION
 332  *  see NAME
 333  *
 334  *   INPUTS
 335  *  empty
 336  *
 337  *   RESULT
 338  *  bExist - true if there is, false otherwise.
 339  *
 340  *   HISTORY
 341  *  05.01.2004 -    implemented
 342  *
 343  *   AUTHOR
 344  *  Michael Mi
 345  *  Email: michael.mi@sun.com
 346  ******************************************************************************/
 347 {
 348     return (m_pBlocker != NULL || m_vElementCollectors.size() > 0);
 349 }
 350
 351 bool BufferNode::hasChildren() const
 352 /****** BufferNode/hasChildren ***********************************************
 353  *
 354  *   NAME
 355  *  hasChildren -- checks whether this BufferNode has any child
 356  *  BufferNode.
 357  *
 358  *   SYNOPSIS
 359  *  bExist = hasChildren();
 360  *
 361  *   FUNCTION
 362  *  see NAME
 363  *
 364  *   INPUTS
 365  *  empty
 366  *
 367  *   RESULT
 368  *  bExist - true if there is, false otherwise.
 369  *
 370  *   HISTORY
 371  *  05.01.2004 -    implemented
 372  *
 373  *   AUTHOR
 374  *  Michael Mi
 375  *  Email: michael.mi@sun.com
 376  ******************************************************************************/
 377 {
 378     return (m_vChildren.size() > 0);
 379 }
 380
 381 std::vector< const BufferNode* >* BufferNode::getChildren() const
 382 {
 383     return new std::vector< const BufferNode* >( m_vChildren );
 384 }
 385
 386 const BufferNode* BufferNode::getFirstChild() const
 387 /****** BufferNode/getFirstChild *********************************************
 388  *
 389  *   NAME
 390  *  getFirstChild -- retrieves the first child BufferNode.
 391  *
 392  *   SYNOPSIS
 393  *  child = getFirstChild();
 394  *
 395  *   FUNCTION
 396  *  see NAME
 397  *
 398  *   INPUTS
 399  *  empty
 400  *
 401  *   RESULT
 402  *  child - the first child BufferNode, or NULL if there is no child
 403  *          BufferNode.
 404  *
 405  *   HISTORY
 406  *  05.01.2004 -    implemented
 407  *
 408  *   AUTHOR
 409  *  Michael Mi
 410  *  Email: michael.mi@sun.com
 411  ******************************************************************************/
 412 {
 413     BufferNode* rc = NULL;
 414
 415     if (m_vChildren.size() > 0)
 416     {
 417         rc = (BufferNode*)m_vChildren.front();
 418     }
 419
 420     return (const BufferNode*)rc;
 421 }
 422
 423 void BufferNode::addChild(const BufferNode* pChild, sal_Int32 nPosition)
 424 /****** BufferNode/addChild(pChild,nPosition) ********************************
 425  *
 426  *   NAME
 427  *  addChild -- inserts a child BufferNode at specific position.
 428  *
 429  *   SYNOPSIS
 430  *  addChild(pChild, nPosition);
 431  *
 432  *   FUNCTION
 433  *  see NAME
 434  *
 435  *   INPUTS
 436  *  pChild -    the child BufferNode to be added.
 437  *  nPosition - the position where the new child locates.
 438  *
 439  *   RESULT
 440  *  empty
 441  *
 442  *   NOTES
 443  *  If the nPosition is -1, then the new child BufferNode is appended
 444  *  at the end.
 445  *
 446  *   HISTORY
 447  *  05.01.2004 -    implemented
 448  *
 449  *   AUTHOR
 450  *  Michael Mi
 451  *  Email: michael.mi@sun.com
 452  ******************************************************************************/
 453 {
 454     if (nPosition == -1)
 455     {
 456         m_vChildren.push_back( pChild );
 457     }
 458     else
 459     {
 460         std::vector< const BufferNode* >::iterator ii = m_vChildren.begin();
 461         ii += nPosition;
 462         m_vChildren.insert(ii, pChild);
 463     }
 464 }
 465
 466 void BufferNode::addChild(const BufferNode* pChild)
 467 /****** BufferNode/addChild() ************************************************
 468  *
 469  *   NAME
 470  *  addChild -- add a new child BufferNode.
 471  *
 472  *   SYNOPSIS
 473  *  addChild(pChild);
 474  *
 475  *   FUNCTION
 476  *  see NAME
 477  *
 478  *   INPUTS
 479  *  pChild -    the child BufferNode to be added.
 480  *
 481  *   RESULT
 482  *  empty
 483  *
 484  *   NOTES
 485  *  The new child BufferNode is appended at the end.
 486  *
 487  *   HISTORY
 488  *  05.01.2004 -    implemented
 489  *
 490  *   AUTHOR
 491  *  Michael Mi
 492  *  Email: michael.mi@sun.com
 493  ******************************************************************************/
 494 {
 495     addChild(pChild, -1);
 496 }
 497
 498 void BufferNode::removeChild(const BufferNode* pChild)
 499 /****** BufferNode/removeChild ***********************************************
 500  *
 501  *   NAME
 502  *  removeChild -- removes a child BufferNode from the children list.
 503  *
 504  *   SYNOPSIS
 505  *  removeChild(pChild);
 506  *
 507  *   FUNCTION
 508  *  see NAME
 509  *
 510  *   INPUTS
 511  *  pChild - the child BufferNode to be removed
 512  *
 513  *   RESULT
 514  *  empty
 515  *
 516  *   HISTORY
 517  *  05.01.2004 -    implemented
 518  *
 519  *   AUTHOR
 520  *  Michael Mi
 521  *  Email: michael.mi@sun.com
 522  ******************************************************************************/
 523 {
 524     std::vector< const BufferNode* >::iterator ii = m_vChildren.begin();
 525
 526     for( ; ii != m_vChildren.end() ; ++ii )
 527     {
 528         if( *ii == pChild )
 529         {
 530             m_vChildren.erase( ii );
 531             break;
 532         }
 533     }
 534 }
 535
 536 sal_Int32 BufferNode::indexOfChild(const BufferNode* pChild) const
 537 /****** BufferNode/indexOfChild **********************************************
 538  *
 539  *   NAME
 540  *  indexOfChild -- gets the index of a child BufferNode.
 541  *
 542  *   SYNOPSIS
 543  *  index = indexOfChild(pChild);
 544  *
 545  *   FUNCTION
 546  *  see NAME
 547  *
 548  *   INPUTS
 549  *  pChild - the child BufferNode whose index to be gotten
 550  *
 551  *   RESULT
 552  *  index - the index of that child BufferNode. If that child BufferNode
 553  *          is not found, -1 is returned.
 554  *
 555  *   HISTORY
 556  *  05.01.2004 -    implemented
 557  *
 558  *   AUTHOR
 559  *  Michael Mi
 560  *  Email: michael.mi@sun.com
 561  ******************************************************************************/
 562 {
 563     sal_Int32 nIndex = 0;
 564     bool bFound = false;
 565
 566     std::vector< const BufferNode * >::const_iterator ii = m_vChildren.begin();
 567
 568     for( ; ii != m_vChildren.end() ; ++ii )
 569     {
 570         if( *ii == pChild )
 571         {
 572             bFound = true;
 573             break;
 574         }
 575         nIndex++;
 576     }
 577
 578     if (!bFound )
 579     {
 580         nIndex = -1;
 581     }
 582
 583     return nIndex;
 584 }
 585
 586 const BufferNode* BufferNode::childAt(sal_Int32 nIndex) const
 587 /****** BufferNode/childAt ***************************************************
 588  *
 589  *   NAME
 590  *  childAt -- retrieves the child BufferNode at specific possition.
 591  *
 592  *   SYNOPSIS
 593  *  child = childAt(nIndex);
 594  *
 595  *   FUNCTION
 596  *  see NAME
 597  *
 598  *   INPUTS
 599  *  nIndex - the index of the child BufferNode to be retrieved
 600  *
 601  *   RESULT
 602  *  child - the child BufferNode at index position, or NULL if the index
 603  *          is out of the range of children.
 604  *
 605  *   HISTORY
 606  *  05.01.2004 -    implemented
 607  *
 608  *   AUTHOR
 609  *  Michael Mi
 610  *  Email: michael.mi@sun.com
 611  ******************************************************************************/
 612 {
 613     BufferNode* rc = NULL;
 614
 615     if (nIndex < ((sal_Int32)m_vChildren.size()) && nIndex >= 0)
 616     {
 617         rc = (BufferNode*)m_vChildren[nIndex];
 618     }
 619
 620     return (const BufferNode*)rc;
 621 }
 622
 623 const BufferNode* BufferNode::getParent() const
 624 {
 625     return m_pParent;
 626 }
 627
 628 void BufferNode::setParent(const BufferNode* pParent)
 629 {
 630     m_pParent = (BufferNode*)pParent;
 631 }
 632
 633 const BufferNode* BufferNode::getNextSibling() const
 634 /****** BufferNode/getNextSibling ********************************************
 635  *
 636  *   NAME
 637  *  getNextSibling -- retrieves the next sibling BufferNode.
 638  *
 639  *   SYNOPSIS
 640  *  sibling = getNextSibling();
 641  *
 642  *   FUNCTION
 643  *  see NAME
 644  *
 645  *   INPUTS
 646  *  empty
 647  *
 648  *   RESULT
 649  *  sibling - the next sibling BufferNode, or NULL if there is none.
 650  *
 651  *   HISTORY
 652  *  05.01.2004 -    implemented
 653  *
 654  *   AUTHOR
 655  *  Michael Mi
 656  *  Email: michael.mi@sun.com
 657  ******************************************************************************/
 658 {
 659     BufferNode* rc = NULL;
 660
 661     if (m_pParent != NULL)
 662     {
 663         rc = (BufferNode*)m_pParent->getNextChild(this);
 664     }
 665
 666     return (const BufferNode*)rc;
 667 }
 668
 669 const BufferNode* BufferNode::isAncestor(const BufferNode* pDescendant) const
 670 /****** BufferNode/isAncestor ************************************************
 671  *
 672  *   NAME
 673  *  isAncestor -- checks whether this BufferNode is an ancestor of another
 674  *  BufferNode.
 675  *
 676  *   SYNOPSIS
 677  *  bIs = isAncestor(pDescendant);
 678  *
 679  *   FUNCTION
 680  *  see NAME
 681  *
 682  *   INPUTS
 683  *  pDescendant -   the BufferNode to be checked as a descendant
 684  *
 685  *   RESULT
 686  *  bIs -   true if this BufferNode is an ancestor of the pDescendant,
 687  *          false otherwise.
 688  *
 689  *   HISTORY
 690  *  05.01.2004 -    implemented
 691  *
 692  *   AUTHOR
 693  *  Michael Mi
 694  *  Email: michael.mi@sun.com
 695  ******************************************************************************/
 696 {
 697     BufferNode* rc = NULL;
 698
 699     if (pDescendant != NULL)
 700     {
 701         std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin();
 702
 703         for( ; ii != m_vChildren.end() ; ++ii )
 704         {
 705             BufferNode* pChild = (BufferNode*)*ii;
 706
 707             if (pChild == pDescendant)
 708             {
 709                 rc = pChild;
 710                 break;
 711             }
 712
 713             if (pChild->isAncestor(pDescendant) != NULL)
 714             {
 715                 rc = pChild;
 716                 break;
 717             }
 718         }
 719     }
 720
 721     return (const BufferNode*)rc;
 722 }
 723
 724 bool BufferNode::isPrevious(const BufferNode* pFollowing) const
 725 /****** BufferNode/isPrevious ************************************************
 726  *
 727  *   NAME
 728  *  isPrevious -- checks whether this BufferNode is ahead of another
 729  *  BufferNode in the tree order.
 730  *
 731  *   SYNOPSIS
 732  *  bIs = isPrevious(pFollowing);
 733  *
 734  *   FUNCTION
 735  *  see NAME
 736  *
 737  *   INPUTS
 738  *  pFollowing -    the BufferNode to be checked as a following
 739  *
 740  *   RESULT
 741  *  bIs -   true if this BufferNode is ahead in the tree order, false
 742  *          otherwise.
 743  *
 744  *   HISTORY
 745  *  05.01.2004 -    implemented
 746  *
 747  *   AUTHOR
 748  *  Michael Mi
 749  *  Email: michael.mi@sun.com
 750  ******************************************************************************/
 751 {
 752     bool rc = false;
 753
 754     BufferNode* pNextBufferNode = (BufferNode*)getNextNodeByTreeOrder();
 755     while (pNextBufferNode != NULL)
 756     {
 757         if (pNextBufferNode == pFollowing)
 758         {
 759             rc = true;
 760             break;
 761         }
 762
 763         pNextBufferNode = (BufferNode*)(pNextBufferNode->getNextNodeByTreeOrder());
 764     }
 765
 766     return rc;
 767 }
 768
 769 const BufferNode* BufferNode::getNextNodeByTreeOrder() const
 770 /****** BufferNode/getNextNodeByTreeOrder ************************************
 771  *
 772  *   NAME
 773  *  getNextNodeByTreeOrder -- retrieves the next BufferNode in the tree
 774  *  order.
 775  *
 776  *   SYNOPSIS
 777  *  next = getNextNodeByTreeOrder();
 778  *
 779  *   FUNCTION
 780  *  see NAME
 781  *
 782  *   INPUTS
 783  *  empty
 784  *
 785  *   RESULT
 786  *  next -  the BufferNode following this BufferNode in the tree order,
 787  *          or NULL if there is none.
 788  *
 789  *   NOTES
 790  *  The "next" node in tree order is defined as:
 791  *  1. If a node has children, then the first child is;
 792  *  2. otherwise, if it has a following sibling, then this sibling node is;
 793  *  3. otherwise, if it has a parent node, the the parent's next sibling
 794  *     node is;
 795  *  4. otherwise, no "next" node exists.
 796  *
 797  *   HISTORY
 798  *  05.01.2004 -    implemented
 799  *
 800  *   AUTHOR
 801  *  Michael Mi
 802  *  Email: michael.mi@sun.com
 803  ******************************************************************************/
 804 {
 805         /*
 806          * If this buffer node has m_vChildren, then return the first
 807          * child.
 808          */
 809     if (hasChildren())
 810     {
 811         return getFirstChild();
 812     }
 813
 814         /*
 815          * Otherwise, it this buffer node has a following sibling,
 816          * then return that sibling.
 817          */
 818     BufferNode* pNextSibling = (BufferNode*)getNextSibling();
 819     if (pNextSibling != NULL)
 820     {
 821         return pNextSibling;
 822     }
 823
 824         /*
 825          * Otherwise, it this buffer node has parent, then return
 826          * its parent's following sibling.
 827          */
 828         BufferNode* pNode = (BufferNode*)this;
 829     BufferNode* pParent;
 830     BufferNode* pNextSiblingParent = NULL;
 831
 832     do
 833     {
 834         if (pNode == NULL)
 835         {
 836             break;
 837         }
 838
 839         pParent = (BufferNode*)pNode->getParent();
 840         if (pParent != NULL)
 841         {
 842             pNextSiblingParent = (BufferNode*)pParent->getNextSibling();
 843         }
 844         pNode = pParent;
 845
 846     }while (pNextSiblingParent == NULL);
 847
 848     return pNextSiblingParent;
 849 }
 850
 851 cssu::Reference< cssxw::XXMLElementWrapper > BufferNode::getXMLElement() const
 852 {
 853     return m_xXMLElement;
 854 }
 855
 856 void BufferNode::setXMLElement( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement )
 857 {
 858     m_xXMLElement = xXMLElement;
 859 }
 860
 861 void BufferNode::notifyBranch()
 862 /****** BufferNode/notifyBranch **********************************************
 863  *
 864  *   NAME
 865  *  notifyBranch -- notifies each BufferNode in the branch of this
 866  *  BufferNode in the tree order.
 867  *
 868  *   SYNOPSIS
 869  *  notifyBranch();
 870  *
 871  *   FUNCTION
 872  *  see NAME
 873  *
 874  *   INPUTS
 875  *  empty
 876  *
 877  *   RESULT
 878  *  empty
 879  *
 880  *   HISTORY
 881  *  05.01.2004 -    implemented
 882  *
 883  *   AUTHOR
 884  *  Michael Mi
 885  *  Email: michael.mi@sun.com
 886  ******************************************************************************/
 887 {
 888     std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin();
 889
 890     for( ; ii != m_vChildren.end() ; ++ii )
 891     {
 892         BufferNode* pBufferNode = (BufferNode*)*ii;
 893         pBufferNode->elementCollectorNotify();
 894         pBufferNode->notifyBranch();
 895     }
 896 }
 897
 898 void BufferNode::notifyAncestor()
 899 /****** BufferNode/notifyAncestor ********************************************
 900  *
 901  *   NAME
 902  *  notifyAncestor -- notifies each ancestor BufferNode through the parent
 903  *  link.
 904  *
 905  *   SYNOPSIS
 906  *  notifyAncestor();
 907  *
 908  *   FUNCTION
 909  *  see NAME
 910  *
 911  *   INPUTS
 912  *  empty
 913  *
 914  *   RESULT
 915  *  empty
 916  *
 917  *   HISTORY
 918  *  05.01.2004 -    implemented
 919  *
 920  *   AUTHOR
 921  *  Michael Mi
 922  *  Email: michael.mi@sun.com
 923  ******************************************************************************/
 924 {
 925     BufferNode* pParent = m_pParent;
 926     while (pParent != NULL)
 927     {
 928         pParent->notifyAncestor();
 929         pParent = (BufferNode*)pParent->getParent();
 930     }
 931 }
 932
 933 void BufferNode::elementCollectorNotify()
 934 /****** BufferNode/elementCollectorNotify ************************************
 935  *
 936  *   NAME
 937  *  elementCollectorNotify -- notifies this BufferNode.
 938  *
 939  *   SYNOPSIS
 940  *  elementCollectorNotify();
 941  *
 942  *   FUNCTION
 943  *  Notifies this BufferNode if the notification is not suppressed.
 944  *
 945  *   INPUTS
 946  *  empty
 947  *
 948  *   RESULT
 949  *  child - the first child BufferNode, or NULL if there is no child
 950  *          BufferNode.
 951  *
 952  *   HISTORY
 953  *  05.01.2004 -    implemented
 954  *
 955  *   AUTHOR
 956  *  Michael Mi
 957  *  Email: michael.mi@sun.com
 958  ******************************************************************************/
 959 {
 960     if (m_vElementCollectors.size()>0)
 961     {
 962         cssxc::sax::ElementMarkPriority nMaxPriority = cssxc::sax::ElementMarkPriority_MINIMUM;
 963         cssxc::sax::ElementMarkPriority nPriority;
 964
 965         /*
 966          * get the max priority among ElementCollectors on this BufferNode
 967          */
 968         std::vector< const ElementCollector* >::const_iterator ii = m_vElementCollectors.begin();
 969         for( ; ii != m_vElementCollectors.end() ; ++ii )
 970         {
 971             ElementCollector* pElementCollector = (ElementCollector*)*ii;
 972             nPriority = pElementCollector->getPriority();
 973             if (nPriority > nMaxPriority)
 974             {
 975                 nMaxPriority = nPriority;
 976             }
 977         }
 978
 979         std::vector< const ElementCollector* > vElementCollectors( m_vElementCollectors );
 980         ii = vElementCollectors.begin();
 981
 982         for( ; ii != vElementCollectors.end() ; ++ii )
 983         {
 984             ElementCollector* pElementCollector = (ElementCollector*)*ii;
 985             nPriority = pElementCollector->getPriority();
 986             bool bToModify = pElementCollector->getModify();
 987
 988             /*
 989              * Only ElementCollector with the max priority can
 990              * perform notify operation.
 991              * Moreover, if any blocker exists in the subtree of
 992              * this BufferNode, this ElementCollector can't do notify
 993              * unless its priority is BEFOREMODIFY.
 994              */
 995             if (nPriority == nMaxPriority &&
 996                 (nPriority == cssxc::sax::ElementMarkPriority_BEFOREMODIFY ||
 997                  !isBlockerInSubTreeIncluded(pElementCollector->getSecurityId())))
 998             {
 999                 /*
1000                  * If this ElementCollector will modify the bufferred element, then
1001                  * special attention must be paid.
1002                  *
1003                  * If there is any ElementCollector in the subtree or any ancestor
1004                  * ElementCollector with PRI_BEFPREMODIFY priority, this
1005                  * ElementCollector can't perform notify operation, otherwise, it
1006                  * will destroy the bufferred element, in turn, ElementCollectors
1007                  * mentioned above can't perform their mission.
1008                  */
1009                 //if (!(nMaxPriority == cssxc::sax::ElementMarkPriority_PRI_MODIFY &&
1010                 if (!(bToModify &&
1011                      (isECInSubTreeIncluded(pElementCollector->getSecurityId()) ||
1012                       isECOfBeforeModifyInAncestorIncluded(pElementCollector->getSecurityId()))
1013                    ))
1014                 {
1015                     pElementCollector->notifyListener();
1016                 }
1017             }
1018         }
1019     }
1020 }
1021
1022 bool BufferNode::isECInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const
1023 /****** BufferNode/isECInSubTreeIncluded *************************************
1024  *
1025  *   NAME
1026  *  isECInSubTreeIncluded -- checks whether there is any ElementCollector
1027  *  in the branch of this BufferNode.
1028  *
1029  *   SYNOPSIS
1030  *  bExist = isECInSubTreeIncluded(nIgnoredSecurityId);
1031  *
1032  *   FUNCTION
1033  *  checks each BufferNode in the branch of this BufferNode, if there is
1034  *  an ElementCollector whose signatureId is not ignored, then return
1035  *  true, otherwise, false returned.
1036  *
1037  *   INPUTS
1038  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
1039  *                          to UNDEFINEDSECURITYID, then no security Id
1040  *                          will be ignored.
1041  *
1042  *   RESULT
1043  *  bExist - true if a match found, false otherwise.
1044  *
1045  *   HISTORY
1046  *  05.01.2004 -    implemented
1047  *
1048  *   AUTHOR
1049  *  Michael Mi
1050  *  Email: michael.mi@sun.com
1051  ******************************************************************************/
1052 {
1053     bool rc = false;
1054
1055     std::vector< const ElementCollector* >::const_iterator jj = m_vElementCollectors.begin();
1056
1057     for( ; jj != m_vElementCollectors.end() ; ++jj )
1058     {
1059         ElementCollector* pElementCollector = (ElementCollector*)*jj;
1060         if (nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
1061              pElementCollector->getSecurityId() != nIgnoredSecurityId)
1062         {
1063             rc = true;
1064             break;
1065         }
1066     }
1067
1068     if ( !rc )
1069     {
1070         std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin();
1071
1072         for( ; ii != m_vChildren.end() ; ++ii )
1073         {
1074             BufferNode* pBufferNode = (BufferNode*)*ii;
1075
1076             if ( pBufferNode->isECInSubTreeIncluded(nIgnoredSecurityId))
1077             {
1078                 rc = true;
1079                 break;
1080             }
1081         }
1082     }
1083
1084     return rc;
1085 }
1086
1087 bool BufferNode::isECOfBeforeModifyInAncestorIncluded(sal_Int32 nIgnoredSecurityId) const
1088 /****** BufferNode/isECOfBeforeModifyInAncestorIncluded **********************
1089  *
1090  *   NAME
1091  *  isECOfBeforeModifyInAncestorIncluded -- checks whether there is some
1092  *  ancestor BufferNode which has ElementCollector with PRI_BEFPREMODIFY
1093  *  priority.
1094  *
1095  *   SYNOPSIS
1096  *  bExist = isECOfBeforeModifyInAncestorIncluded(nIgnoredSecurityId);
1097  *
1098  *   FUNCTION
1099  *  checks each ancestor BufferNode through the parent link, if there is
1100  *  an ElementCollector with PRI_BEFPREMODIFY priority and its
1101  *  signatureId is not ignored, then return true, otherwise, false
1102  *  returned.
1103  *
1104  *   INPUTS
1105  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
1106  *                          to UNDEFINEDSECURITYID, then no security Id
1107  *                          will be ignored.
1108  *
1109  *   RESULT
1110  *  bExist - true if a match found, false otherwise.
1111  *
1112  *   HISTORY
1113  *  05.01.2004 -    implemented
1114  *
1115  *   AUTHOR
1116  *  Michael Mi
1117  *  Email: michael.mi@sun.com
1118  ******************************************************************************/
1119 {
1120     bool rc = false;
1121
1122     BufferNode* pParentNode = m_pParent;
1123     while (pParentNode != NULL)
1124     {
1125         if (pParentNode->isECOfBeforeModifyIncluded(nIgnoredSecurityId))
1126         {
1127             rc = true;
1128             break;
1129         }
1130
1131         pParentNode = (BufferNode*)pParentNode->getParent();
1132     }
1133
1134     return rc;
1135 }
1136
1137 bool BufferNode::isBlockerInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const
1138 /****** BufferNode/isBlockerInSubTreeIncluded ********************************
1139  *
1140  *   NAME
1141  *  isBlockerInSubTreeIncluded -- checks whether there is some BufferNode
1142  *  which has blocker on it
1143  *
1144  *   SYNOPSIS
1145  *  bExist = isBlockerInSubTreeIncluded(nIgnoredSecurityId);
1146  *
1147  *   FUNCTION
1148  *  checks each BufferNode in the branch of this BufferNode, if one has
1149  *  a blocker on it, and the blocker's securityId is not ignored, then
1150  *  returns true; otherwise, false returns.
1151  *
1152  *   INPUTS
1153  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
1154  *                          to UNDEFINEDSECURITYID, then no security Id
1155  *                          will be ignored.
1156  *
1157  *   RESULT
1158  *  bExist - true if a match found, false otherwise.
1159  *
1160  *   HISTORY
1161  *  05.01.2004 -    implemented
1162  *
1163  *   AUTHOR
1164  *  Michael Mi
1165  *  Email: michael.mi@sun.com
1166  ******************************************************************************/
1167 {
1168     bool rc = false;
1169
1170     std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin();
1171
1172     for( ; ii != m_vChildren.end() ; ++ii )
1173     {
1174         BufferNode* pBufferNode = (BufferNode*)*ii;
1175         ElementMark* pBlocker = pBufferNode->getBlocker();
1176
1177         if (pBlocker != NULL &&
1178             (nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
1179             pBlocker->getSecurityId() != nIgnoredSecurityId ))
1180         {
1181             rc = true;
1182             break;
1183         }
1184
1185         if (rc || pBufferNode->isBlockerInSubTreeIncluded(nIgnoredSecurityId))
1186         {
1187             rc = true;
1188             break;
1189         }
1190     }
1191
1192     return rc;
1193 }
1194
1195 const BufferNode* BufferNode::getNextChild(const BufferNode* pChild) const
1196 /****** BufferNode/getNextChild **********************************************
1197  *
1198  *   NAME
1199  *  getNextChild -- get the next child BufferNode.
1200  *
1201  *   SYNOPSIS
1202  *  nextChild = getNextChild();
1203  *
1204  *   FUNCTION
1205  *  see NAME
1206  *
1207  *   INPUTS
1208  *  pChild - the child BufferNode whose next node is retrieved.
1209  *
1210  *   RESULT
1211  *  nextChild - the next child BufferNode after the pChild, or NULL if
1212  *  there is none.
1213  *
1214  *   HISTORY
1215  *  05.01.2004 -    implemented
1216  *
1217  *   AUTHOR
1218  *  Michael Mi
1219  *  Email: michael.mi@sun.com
1220  ******************************************************************************/
1221 {
1222     BufferNode* rc = NULL;
1223     bool bChildFound = false;
1224
1225     std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin();
1226     for( ; ii != m_vChildren.end() ; ++ii )
1227     {
1228         if (bChildFound)
1229         {
1230             rc = (BufferNode*)*ii;
1231             break;
1232         }
1233
1234         if( *ii == pChild )
1235         {
1236             bChildFound = true;
1237         }
1238     }
1239
1240     return (const BufferNode*)rc;
1241 }
1242
1243
1244 void BufferNode::freeAllChildren()
1245 /****** BufferNode/freeAllChildren *******************************************
1246  *
1247  *   NAME
1248  *  freeAllChildren -- free all his child BufferNode.
1249  *
1250  *   SYNOPSIS
1251  *  freeAllChildren();
1252  *
1253  *   FUNCTION
1254  *  see NAME
1255  *
1256  *   INPUTS
1257  *  empty
1258  *
1259  *   RESULT
1260  *  empty
1261  *
1262  *   HISTORY
1263  *  30.03.2004 -    the correct the memory leak bug
1264  *
1265  *   AUTHOR
1266  *  Michael Mi
1267  *  Email: michael.mi@sun.com
1268  ******************************************************************************/
1269 {
1270     std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin();
1271     for( ; ii != m_vChildren.end() ; ++ii )
1272     {
1273         BufferNode *pChild = (BufferNode *)(*ii);
1274         pChild->freeAllChildren();
1275         delete pChild;
1276     }
1277
1278     m_vChildren.clear();
1279 }