LCOV - code coverage report
Current view: top level - libreoffice/xmlsecurity/source/framework - buffernode.cxx (source / functions) Hit Total Coverage
Test: libreoffice_filtered.info Lines: 0 250 0.0 %
Date: 2012-12-27 Functions: 0 33 0.0 %
Legend: Lines: hit not hit

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

Generated by: LCOV version 1.10