xmlsecurity/source/framework/buffernode.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 "elementmark.hxx"
  22 #include "elementcollector.hxx"
  23 #include "buffernode.hxx"
  24 #include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp>
  25 #include <osl/diagnose.h>
  26 #include <rtl/ustrbuf.hxx>
  27
  28 namespace cssu = com::sun::star::uno;
  29 namespace cssxw = com::sun::star::xml::wrapper;
  30 namespace cssxc = com::sun::star::xml::crypto;
  31
  32 BufferNode::BufferNode( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement )
  33     :m_pParent(nullptr),
  34      m_pBlocker(nullptr),
  35      m_bAllReceived(false),
  36      m_xXMLElement(xXMLElement)
  37 {
  38 }
  39
  40 bool BufferNode::isECOfBeforeModifyIncluded(sal_Int32 nIgnoredSecurityId) const
  41 /****** BufferNode/isECOfBeforeModifyIncluded ********************************
  42  *
  43  *   NAME
  44  *  isECOfBeforeModifyIncluded -- checks whether there is some
  45  *  ElementCollector on this BufferNode, that has BEFORE-MODIFY priority.
  46  *
  47  *   SYNOPSIS
  48  *  bExist = isECOfBeforeModifyIncluded(nIgnoredSecurityId);
  49  *
  50  *   FUNCTION
  51  *  checks each ElementCollector on this BufferNode, if all following
  52  *  conditions are satisfied, then returns true:
  53  *  1. the ElementCollector's priority is BEFOREMODIFY;
  54  *  2. the ElementCollector's securityId can't be ignored.
  55  *  otherwise, returns false.
  56  *
  57  *   INPUTS
  58  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
  59  *                          to UNDEFINEDSECURITYID, then no security Id
  60  *                          will be ignored.
  61  *
  62  *   RESULT
  63  *  bExist - true if a match found, false otherwise
  64  ******************************************************************************/
  65 {
  66     return std::any_of(m_vElementCollectors.cbegin(), m_vElementCollectors.cend(),
  67         [nIgnoredSecurityId](const ElementCollector* pElementCollector) {
  68             return (nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
  69                     pElementCollector->getSecurityId() != nIgnoredSecurityId) &&
  70                    (pElementCollector->getPriority() == cssxc::sax::ElementMarkPriority_BEFOREMODIFY);
  71         });
  72 }
  73
  74 void BufferNode::setReceivedAll()
  75 /****** BufferNode/setReceiveAll *********************************************
  76  *
  77  *   NAME
  78  *  setReceivedAll -- indicates that the element in this BufferNode has
  79  *  been completely buffered.
  80  *
  81  *   SYNOPSIS
  82  *  setReceivedAll();
  83  *
  84  *   FUNCTION
  85  *  sets the all-received flag and launches ElementCollector's notify
  86  *  process.
  87  *
  88  *   INPUTS
  89  *  empty
  90  *
  91  *   RESULT
  92  *  empty
  93  ******************************************************************************/
  94 {
  95     m_bAllReceived = true;
  96     elementCollectorNotify();
  97 }
  98
  99
 100 void BufferNode::addElementCollector(const ElementCollector* pElementCollector)
 101 /****** BufferNode/addElementCollector ***************************************
 102  *
 103  *   NAME
 104  *  addElementCollector -- adds a new ElementCollector to this BufferNode.
 105  *
 106  *   SYNOPSIS
 107  *  addElementCollector(pElementCollector);
 108  *
 109  *   FUNCTION
 110  *  see NAME
 111  *
 112  *   INPUTS
 113  *  pElementCollector - the ElementCollector to be added
 114  *
 115  *   RESULT
 116  *  empty
 117  ******************************************************************************/
 118 {
 119     m_vElementCollectors.push_back( pElementCollector );
 120     const_cast<ElementCollector*>(pElementCollector)->setBufferNode(this);
 121 }
 122
 123 void BufferNode::removeElementCollector(const ElementCollector* pElementCollector)
 124 /****** BufferNode/removeElementCollector ************************************
 125  *
 126  *   NAME
 127  *  removeElementCollector -- removes an ElementCollector from this
 128  *  BufferNode.
 129  *
 130  *   SYNOPSIS
 131  *  removeElementCollector(pElementCollector);
 132  *
 133  *   FUNCTION
 134  *  see NAME
 135  *
 136  *   INPUTS
 137  *  pElementCollector - the ElementCollector to be removed
 138  *
 139  *   RESULT
 140  *  empty
 141  ******************************************************************************/
 142 {
 143     auto ii = std::find(m_vElementCollectors.begin(), m_vElementCollectors.end(), pElementCollector);
 144     if (ii != m_vElementCollectors.end())
 145     {
 146         m_vElementCollectors.erase( ii );
 147         const_cast<ElementCollector*>(pElementCollector)->setBufferNode(nullptr);
 148     }
 149 }
 150
 151
 152 void BufferNode::setBlocker(const ElementMark* pBlocker)
 153 /****** BufferNode/setBlocker ************************************************
 154  *
 155  *   NAME
 156  *  setBlocker -- adds a blocker to this BufferNode.
 157  *
 158  *   SYNOPSIS
 159  *  setBlocker(pBlocker);
 160  *
 161  *   FUNCTION
 162  *  see NAME
 163  *
 164  *   INPUTS
 165  *  pBlocker - the new blocker to be attached
 166  *
 167  *   RESULT
 168  *  empty
 169  *
 170  *   NOTES
 171  *  Because there is only one blocker permitted for a BufferNode, so the
 172  *  old blocker on this BufferNode, if there is one, will be overcasted.
 173  ******************************************************************************/
 174 {
 175     OSL_ASSERT(!(m_pBlocker != nullptr && pBlocker != nullptr));
 176
 177     m_pBlocker = const_cast<ElementMark*>(pBlocker);
 178     if (m_pBlocker != nullptr)
 179     {
 180         m_pBlocker->setBufferNode(this);
 181     }
 182 }
 183
 184 OUString BufferNode::printChildren() const
 185 /****** BufferNode/printChildren *********************************************
 186  *
 187  *   NAME
 188  *  printChildren -- prints children information into a string.
 189  *
 190  *   SYNOPSIS
 191  *  result = printChildren();
 192  *
 193  *   FUNCTION
 194  *  see NAME
 195  *
 196  *   INPUTS
 197  *  empty
 198  *
 199  *   RESULT
 200  *  result - the information string
 201  ******************************************************************************/
 202 {
 203     OUStringBuffer rc;
 204
 205     for( const ElementCollector* ii : m_vElementCollectors )
 206     {
 207         rc.append("BufID=").append(OUString::number(ii->getBufferId()));
 208
 209         if (ii->getModify())
 210         {
 211             rc.append("[M]");
 212         }
 213
 214         rc.append(",Pri=");
 215
 216         switch (ii->getPriority())
 217         {
 218             case cssxc::sax::ElementMarkPriority_BEFOREMODIFY:
 219                 rc.append("BEFOREMODIFY");
 220                 break;
 221             case cssxc::sax::ElementMarkPriority_AFTERMODIFY:
 222                 rc.append("AFTERMODIFY");
 223                 break;
 224             default:
 225                 rc.append("UNKNOWN");
 226                 break;
 227         }
 228
 229         rc.append("(SecID=").append(OUString::number(ii->getSecurityId())).append(") ");
 230     }
 231
 232     return rc.makeStringAndClear();
 233 }
 234
 235 bool BufferNode::hasAnything() const
 236 /****** BufferNode/hasAnything ***********************************************
 237  *
 238  *   NAME
 239  *  hasAnything -- checks whether there is any ElementCollector or blocker
 240  *  on this BufferNode.
 241  *
 242  *   SYNOPSIS
 243  *  bExist = hasAnything();
 244  *
 245  *   FUNCTION
 246  *  see NAME
 247  *
 248  *   INPUTS
 249  *  empty
 250  *
 251  *   RESULT
 252  *  bExist - true if there is, false otherwise.
 253  ******************************************************************************/
 254 {
 255     return (m_pBlocker || !m_vElementCollectors.empty());
 256 }
 257
 258 bool BufferNode::hasChildren() const
 259 /****** BufferNode/hasChildren ***********************************************
 260  *
 261  *   NAME
 262  *  hasChildren -- checks whether this BufferNode has any child
 263  *  BufferNode.
 264  *
 265  *   SYNOPSIS
 266  *  bExist = hasChildren();
 267  *
 268  *   FUNCTION
 269  *  see NAME
 270  *
 271  *   INPUTS
 272  *  empty
 273  *
 274  *   RESULT
 275  *  bExist - true if there is, false otherwise.
 276  ******************************************************************************/
 277 {
 278     return (!m_vChildren.empty());
 279 }
 280
 281 std::vector< std::unique_ptr<BufferNode> > const & BufferNode::getChildren() const
 282 {
 283     return m_vChildren;
 284 }
 285
 286 std::vector< std::unique_ptr<BufferNode> > BufferNode::releaseChildren()
 287 {
 288     return std::move(m_vChildren);
 289 }
 290
 291 const BufferNode* BufferNode::getFirstChild() const
 292 /****** BufferNode/getFirstChild *********************************************
 293  *
 294  *   NAME
 295  *  getFirstChild -- retrieves the first child BufferNode.
 296  *
 297  *   SYNOPSIS
 298  *  child = getFirstChild();
 299  *
 300  *   FUNCTION
 301  *  see NAME
 302  *
 303  *   INPUTS
 304  *  empty
 305  *
 306  *   RESULT
 307  *  child - the first child BufferNode, or NULL if there is no child
 308  *          BufferNode.
 309  ******************************************************************************/
 310 {
 311     BufferNode* rc = nullptr;
 312
 313     if (!m_vChildren.empty())
 314     {
 315         rc = m_vChildren.front().get();
 316     }
 317
 318     return rc;
 319 }
 320
 321 void BufferNode::addChild(std::unique_ptr<BufferNode> pChild, sal_Int32 nPosition)
 322 /****** BufferNode/addChild(pChild,nPosition) ********************************
 323  *
 324  *   NAME
 325  *  addChild -- inserts a child BufferNode at specific position.
 326  *
 327  *   SYNOPSIS
 328  *  addChild(pChild, nPosition);
 329  *
 330  *   FUNCTION
 331  *  see NAME
 332  *
 333  *   INPUTS
 334  *  pChild -    the child BufferNode to be added.
 335  *  nPosition - the position where the new child locates.
 336  *
 337  *   RESULT
 338  *  empty
 339  *
 340  *   NOTES
 341  *  If the nPosition is -1, then the new child BufferNode is appended
 342  *  at the end.
 343  ******************************************************************************/
 344 {
 345     if (nPosition == -1)
 346     {
 347         m_vChildren.push_back( std::move(pChild) );
 348     }
 349     else
 350     {
 351         m_vChildren.insert(m_vChildren.begin() + nPosition, std::move(pChild));
 352     }
 353 }
 354
 355 void BufferNode::addChild(std::unique_ptr<BufferNode> pChild)
 356 /****** BufferNode/addChild() ************************************************
 357  *
 358  *   NAME
 359  *  addChild -- add a new child BufferNode.
 360  *
 361  *   SYNOPSIS
 362  *  addChild(pChild);
 363  *
 364  *   FUNCTION
 365  *  see NAME
 366  *
 367  *   INPUTS
 368  *  pChild -    the child BufferNode to be added.
 369  *
 370  *   RESULT
 371  *  empty
 372  *
 373  *   NOTES
 374  *  The new child BufferNode is appended at the end.
 375  ******************************************************************************/
 376 {
 377     addChild(std::move(pChild), -1);
 378 }
 379
 380 void BufferNode::removeChild(const BufferNode* pChild)
 381 /****** BufferNode/removeChild ***********************************************
 382  *
 383  *   NAME
 384  *  removeChild -- removes and deletes a child BufferNode from the children list.
 385  *
 386  *   SYNOPSIS
 387  *  removeChild(pChild);
 388  *
 389  *   FUNCTION
 390  *  see NAME
 391  *
 392  *   INPUTS
 393  *  pChild - the child BufferNode to be removed
 394  *
 395  *   RESULT
 396  *  empty
 397  ******************************************************************************/
 398 {
 399     auto ii = std::find_if(m_vChildren.begin(), m_vChildren.end(),
 400                 [pChild] (const std::unique_ptr<BufferNode>& i)
 401                 { return i.get() == pChild; });
 402     if (ii != m_vChildren.end())
 403         m_vChildren.erase( ii );
 404 }
 405
 406 sal_Int32 BufferNode::indexOfChild(const BufferNode* pChild) const
 407 /****** BufferNode/indexOfChild **********************************************
 408  *
 409  *   NAME
 410  *  indexOfChild -- gets the index of a child BufferNode.
 411  *
 412  *   SYNOPSIS
 413  *  index = indexOfChild(pChild);
 414  *
 415  *   FUNCTION
 416  *  see NAME
 417  *
 418  *   INPUTS
 419  *  pChild - the child BufferNode whose index to be gotten
 420  *
 421  *   RESULT
 422  *  index - the index of that child BufferNode. If that child BufferNode
 423  *          is not found, -1 is returned.
 424  ******************************************************************************/
 425 {
 426     auto ii = std::find_if(m_vChildren.begin(), m_vChildren.end(),
 427             [pChild] (const std::unique_ptr<BufferNode>& i)
 428             { return i.get() == pChild; });
 429     if (ii == m_vChildren.end())
 430         return -1;
 431
 432     return std::distance(m_vChildren.begin(), ii);
 433 }
 434
 435
 436 void BufferNode::setParent(const BufferNode* pParent)
 437 {
 438     m_pParent = const_cast<BufferNode*>(pParent);
 439 }
 440
 441 const BufferNode* BufferNode::getNextSibling() const
 442 /****** BufferNode/getNextSibling ********************************************
 443  *
 444  *   NAME
 445  *  getNextSibling -- retrieves the next sibling BufferNode.
 446  *
 447  *   SYNOPSIS
 448  *  sibling = getNextSibling();
 449  *
 450  *   FUNCTION
 451  *  see NAME
 452  *
 453  *   INPUTS
 454  *  empty
 455  *
 456  *   RESULT
 457  *  sibling - the next sibling BufferNode, or NULL if there is none.
 458  ******************************************************************************/
 459 {
 460     BufferNode* rc = nullptr;
 461
 462     if (m_pParent != nullptr)
 463     {
 464         rc = const_cast<BufferNode*>(m_pParent->getNextChild(this));
 465     }
 466
 467     return rc;
 468 }
 469
 470 const BufferNode* BufferNode::isAncestor(const BufferNode* pDescendant) const
 471 /****** BufferNode/isAncestor ************************************************
 472  *
 473  *   NAME
 474  *  isAncestor -- checks whether this BufferNode is an ancestor of another
 475  *  BufferNode.
 476  *
 477  *   SYNOPSIS
 478  *  bIs = isAncestor(pDescendant);
 479  *
 480  *   FUNCTION
 481  *  see NAME
 482  *
 483  *   INPUTS
 484  *  pDescendant -   the BufferNode to be checked as a descendant
 485  *
 486  *   RESULT
 487  *  bIs -   true if this BufferNode is an ancestor of the pDescendant,
 488  *          false otherwise.
 489  ******************************************************************************/
 490 {
 491     BufferNode* rc = nullptr;
 492
 493     if (pDescendant != nullptr)
 494     {
 495         auto ii = std::find_if(m_vChildren.cbegin(), m_vChildren.cend(),
 496             [&pDescendant](const std::unique_ptr<BufferNode>& pChild) {
 497                 return (pChild.get() == pDescendant) || (pChild->isAncestor(pDescendant) != nullptr);
 498             });
 499
 500         if (ii != m_vChildren.end())
 501             rc = ii->get();
 502     }
 503
 504     return rc;
 505 }
 506
 507 bool BufferNode::isPrevious(const BufferNode* pFollowing) const
 508 /****** BufferNode/isPrevious ************************************************
 509  *
 510  *   NAME
 511  *  isPrevious -- checks whether this BufferNode is ahead of another
 512  *  BufferNode in the tree order.
 513  *
 514  *   SYNOPSIS
 515  *  bIs = isPrevious(pFollowing);
 516  *
 517  *   FUNCTION
 518  *  see NAME
 519  *
 520  *   INPUTS
 521  *  pFollowing -    the BufferNode to be checked as a following
 522  *
 523  *   RESULT
 524  *  bIs -   true if this BufferNode is ahead in the tree order, false
 525  *          otherwise.
 526  ******************************************************************************/
 527 {
 528     bool rc = false;
 529
 530     BufferNode* pNextBufferNode = const_cast<BufferNode*>(getNextNodeByTreeOrder());
 531     while (pNextBufferNode != nullptr)
 532     {
 533         if (pNextBufferNode == pFollowing)
 534         {
 535             rc = true;
 536             break;
 537         }
 538
 539         pNextBufferNode = const_cast<BufferNode*>(pNextBufferNode->getNextNodeByTreeOrder());
 540     }
 541
 542     return rc;
 543 }
 544
 545 const BufferNode* BufferNode::getNextNodeByTreeOrder() const
 546 /****** BufferNode/getNextNodeByTreeOrder ************************************
 547  *
 548  *   NAME
 549  *  getNextNodeByTreeOrder -- retrieves the next BufferNode in the tree
 550  *  order.
 551  *
 552  *   SYNOPSIS
 553  *  next = getNextNodeByTreeOrder();
 554  *
 555  *   FUNCTION
 556  *  see NAME
 557  *
 558  *   INPUTS
 559  *  empty
 560  *
 561  *   RESULT
 562  *  next -  the BufferNode following this BufferNode in the tree order,
 563  *          or NULL if there is none.
 564  *
 565  *   NOTES
 566  *  The "next" node in tree order is defined as:
 567  *  1. If a node has children, then the first child is;
 568  *  2. otherwise, if it has a following sibling, then this sibling node is;
 569  *  3. otherwise, if it has a parent node, the parent's next sibling
 570  *     node is;
 571  *  4. otherwise, no "next" node exists.
 572  ******************************************************************************/
 573 {
 574     /*
 575      * If this buffer node has m_vChildren, then return the first
 576      * child.
 577      */
 578     if (hasChildren())
 579     {
 580         return getFirstChild();
 581     }
 582
 583     /*
 584      * Otherwise, it this buffer node has a following sibling,
 585      * then return that sibling.
 586      */
 587     BufferNode* pNextSibling = const_cast<BufferNode*>(getNextSibling());
 588     if (pNextSibling != nullptr)
 589     {
 590         return pNextSibling;
 591     }
 592
 593     /*
 594      * Otherwise, it this buffer node has parent, then return
 595      * its parent's following sibling.
 596      */
 597     BufferNode* pNode = const_cast<BufferNode*>(this);
 598     BufferNode* pParent;
 599     BufferNode* pNextSiblingParent = nullptr;
 600
 601     do
 602     {
 603         if (pNode == nullptr)
 604         {
 605             break;
 606         }
 607
 608         pParent = const_cast<BufferNode*>(pNode->getParent());
 609         if (pParent != nullptr)
 610         {
 611             pNextSiblingParent = const_cast<BufferNode*>(pParent->getNextSibling());
 612         }
 613         pNode = pParent;
 614
 615     } while (pNextSiblingParent == nullptr);
 616
 617     return pNextSiblingParent;
 618 }
 619
 620
 621 void BufferNode::setXMLElement( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement )
 622 {
 623     m_xXMLElement = xXMLElement;
 624 }
 625
 626 void BufferNode::notifyBranch()
 627 /****** BufferNode/notifyBranch **********************************************
 628  *
 629  *   NAME
 630  *  notifyBranch -- notifies each BufferNode in the branch of this
 631  *  BufferNode in the tree order.
 632  *
 633  *   SYNOPSIS
 634  *  notifyBranch();
 635  *
 636  *   FUNCTION
 637  *  see NAME
 638  *
 639  *   INPUTS
 640  *  empty
 641  *
 642  *   RESULT
 643  *  empty
 644  ******************************************************************************/
 645 {
 646     for( std::unique_ptr<BufferNode>& pBufferNode : m_vChildren )
 647     {
 648         pBufferNode->elementCollectorNotify();
 649         pBufferNode->notifyBranch();
 650     }
 651 }
 652
 653 void BufferNode::elementCollectorNotify()
 654 /****** BufferNode/elementCollectorNotify ************************************
 655  *
 656  *   NAME
 657  *  elementCollectorNotify -- notifies this BufferNode.
 658  *
 659  *   SYNOPSIS
 660  *  elementCollectorNotify();
 661  *
 662  *   FUNCTION
 663  *  Notifies this BufferNode if the notification is not suppressed.
 664  *
 665  *   INPUTS
 666  *  empty
 667  *
 668  *   RESULT
 669  *  child - the first child BufferNode, or NULL if there is no child
 670  *          BufferNode.
 671  ******************************************************************************/
 672 {
 673     if (!m_vElementCollectors.empty())
 674     {
 675         cssxc::sax::ElementMarkPriority nMaxPriority = cssxc::sax::ElementMarkPriority_MINIMUM;
 676         cssxc::sax::ElementMarkPriority nPriority;
 677
 678         /*
 679          * get the max priority among ElementCollectors on this BufferNode
 680          */
 681         for( const ElementCollector* pElementCollector : m_vElementCollectors )
 682         {
 683             nPriority = pElementCollector->getPriority();
 684             if (nPriority > nMaxPriority)
 685             {
 686                 nMaxPriority = nPriority;
 687             }
 688         }
 689
 690         std::vector< const ElementCollector* > vElementCollectors( m_vElementCollectors );
 691
 692         for( const ElementCollector* ii : vElementCollectors )
 693         {
 694             ElementCollector* pElementCollector = const_cast<ElementCollector*>(ii);
 695             nPriority = pElementCollector->getPriority();
 696             bool bToModify = pElementCollector->getModify();
 697
 698             /*
 699              * Only ElementCollector with the max priority can
 700              * perform notify operation.
 701              * Moreover, if any blocker exists in the subtree of
 702              * this BufferNode, this ElementCollector can't do notify
 703              * unless its priority is BEFOREMODIFY.
 704              */
 705             if (nPriority == nMaxPriority &&
 706                 (nPriority == cssxc::sax::ElementMarkPriority_BEFOREMODIFY ||
 707                  !isBlockerInSubTreeIncluded(pElementCollector->getSecurityId())))
 708             {
 709                 /*
 710                  * If this ElementCollector will modify the buffered element, then
 711                  * special attention must be paid.
 712                  *
 713                  * If there is any ElementCollector in the subtree or any ancestor
 714                  * ElementCollector with PRI_BEFPREMODIFY priority, this
 715                  * ElementCollector can't perform notify operation, otherwise, it
 716                  * will destroy the buffered element, in turn, ElementCollectors
 717                  * mentioned above can't perform their mission.
 718                  */
 719                 //if (!(nMaxPriority == cssxc::sax::ElementMarkPriority_PRI_MODIFY &&
 720                 if (!(bToModify &&
 721                      (isECInSubTreeIncluded(pElementCollector->getSecurityId()) ||
 722                       isECOfBeforeModifyInAncestorIncluded(pElementCollector->getSecurityId()))
 723                    ))
 724                 {
 725                     pElementCollector->notifyListener();
 726                 }
 727             }
 728         }
 729     }
 730 }
 731
 732 bool BufferNode::isECInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const
 733 /****** BufferNode/isECInSubTreeIncluded *************************************
 734  *
 735  *   NAME
 736  *  isECInSubTreeIncluded -- checks whether there is any ElementCollector
 737  *  in the branch of this BufferNode.
 738  *
 739  *   SYNOPSIS
 740  *  bExist = isECInSubTreeIncluded(nIgnoredSecurityId);
 741  *
 742  *   FUNCTION
 743  *  checks each BufferNode in the branch of this BufferNode, if there is
 744  *  an ElementCollector whose signatureId is not ignored, then return
 745  *  true, otherwise, false returned.
 746  *
 747  *   INPUTS
 748  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
 749  *                          to UNDEFINEDSECURITYID, then no security Id
 750  *                          will be ignored.
 751  *
 752  *   RESULT
 753  *  bExist - true if a match found, false otherwise.
 754  ******************************************************************************/
 755 {
 756     bool rc = std::any_of(m_vElementCollectors.begin(), m_vElementCollectors.end(),
 757         [nIgnoredSecurityId](const ElementCollector* pElementCollector) {
 758             return nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
 759                 pElementCollector->getSecurityId() != nIgnoredSecurityId;
 760     });
 761
 762     if ( !rc )
 763     {
 764         rc = std::any_of(m_vChildren.begin(), m_vChildren.end(),
 765             [nIgnoredSecurityId](const std::unique_ptr<BufferNode>& pBufferNode) {
 766                 return pBufferNode->isECInSubTreeIncluded(nIgnoredSecurityId);
 767         });
 768     }
 769
 770     return rc;
 771 }
 772
 773 bool BufferNode::isECOfBeforeModifyInAncestorIncluded(sal_Int32 nIgnoredSecurityId) const
 774 /****** BufferNode/isECOfBeforeModifyInAncestorIncluded **********************
 775  *
 776  *   NAME
 777  *  isECOfBeforeModifyInAncestorIncluded -- checks whether there is some
 778  *  ancestor BufferNode which has ElementCollector with PRI_BEFPREMODIFY
 779  *  priority.
 780  *
 781  *   SYNOPSIS
 782  *  bExist = isECOfBeforeModifyInAncestorIncluded(nIgnoredSecurityId);
 783  *
 784  *   FUNCTION
 785  *  checks each ancestor BufferNode through the parent link, if there is
 786  *  an ElementCollector with PRI_BEFPREMODIFY priority and its
 787  *  signatureId is not ignored, then return true, otherwise, false
 788  *  returned.
 789  *
 790  *   INPUTS
 791  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
 792  *                          to UNDEFINEDSECURITYID, then no security Id
 793  *                          will be ignored.
 794  *
 795  *   RESULT
 796  *  bExist - true if a match found, false otherwise.
 797  ******************************************************************************/
 798 {
 799     bool rc = false;
 800
 801     BufferNode* pParentNode = m_pParent;
 802     while (pParentNode != nullptr)
 803     {
 804         if (pParentNode->isECOfBeforeModifyIncluded(nIgnoredSecurityId))
 805         {
 806             rc = true;
 807             break;
 808         }
 809
 810         pParentNode = const_cast<BufferNode*>(pParentNode->getParent());
 811     }
 812
 813     return rc;
 814 }
 815
 816 bool BufferNode::isBlockerInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const
 817 /****** BufferNode/isBlockerInSubTreeIncluded ********************************
 818  *
 819  *   NAME
 820  *  isBlockerInSubTreeIncluded -- checks whether there is some BufferNode
 821  *  which has blocker on it
 822  *
 823  *   SYNOPSIS
 824  *  bExist = isBlockerInSubTreeIncluded(nIgnoredSecurityId);
 825  *
 826  *   FUNCTION
 827  *  checks each BufferNode in the branch of this BufferNode, if one has
 828  *  a blocker on it, and the blocker's securityId is not ignored, then
 829  *  returns true; otherwise, false returns.
 830  *
 831  *   INPUTS
 832  *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
 833  *                          to UNDEFINEDSECURITYID, then no security Id
 834  *                          will be ignored.
 835  *
 836  *   RESULT
 837  *  bExist - true if a match found, false otherwise.
 838  ******************************************************************************/
 839 {
 840     return std::any_of(m_vChildren.begin(), m_vChildren.end(),
 841         [nIgnoredSecurityId](const std::unique_ptr<BufferNode>& pBufferNode) {
 842             ElementMark* pBlocker = pBufferNode->getBlocker();
 843             return (pBlocker != nullptr &&
 844                 (nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
 845                  pBlocker->getSecurityId() != nIgnoredSecurityId )) ||
 846                 pBufferNode->isBlockerInSubTreeIncluded(nIgnoredSecurityId);
 847     });
 848 }
 849
 850 const BufferNode* BufferNode::getNextChild(const BufferNode* pChild) const
 851 /****** BufferNode/getNextChild **********************************************
 852  *
 853  *   NAME
 854  *  getNextChild -- get the next child BufferNode.
 855  *
 856  *   SYNOPSIS
 857  *  nextChild = getNextChild();
 858  *
 859  *   FUNCTION
 860  *  see NAME
 861  *
 862  *   INPUTS
 863  *  pChild - the child BufferNode whose next node is retrieved.
 864  *
 865  *   RESULT
 866  *  nextChild - the next child BufferNode after the pChild, or NULL if
 867  *  there is none.
 868  ******************************************************************************/
 869 {
 870     BufferNode* rc = nullptr;
 871     bool bChildFound = false;
 872
 873     for( std::unique_ptr<BufferNode> const & i : m_vChildren )
 874     {
 875         if (bChildFound)
 876         {
 877             rc = i.get();
 878             break;
 879         }
 880
 881         if( i.get() == pChild )
 882         {
 883             bChildFound = true;
 884         }
 885     }
 886
 887     return rc;
 888 }
 889
 890 /* vim:set shiftwidth=4 softtabstop=4 expandtab: */