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