| /************************************************************** |
| * |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, |
| * software distributed under the License is distributed on an |
| * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| * KIND, either express or implied. See the License for the |
| * specific language governing permissions and limitations |
| * under the License. |
| * |
| *************************************************************/ |
| |
| |
| |
| // MARKER(update_precomp.py): autogen include statement, do not remove |
| #include "precompiled_xmlsecurity.hxx" |
| |
| #include "elementmark.hxx" |
| #include "elementcollector.hxx" |
| #include "buffernode.hxx" |
| #include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp> |
| |
| namespace cssu = com::sun::star::uno; |
| namespace cssxw = com::sun::star::xml::wrapper; |
| namespace cssxc = com::sun::star::xml::crypto; |
| |
| BufferNode::BufferNode( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement ) |
| :m_pParent(NULL), |
| m_pBlocker(NULL), |
| m_bAllReceived(false), |
| m_xXMLElement(xXMLElement) |
| { |
| } |
| |
| bool BufferNode::isECOfBeforeModifyIncluded(sal_Int32 nIgnoredSecurityId) const |
| /****** BufferNode/isECOfBeforeModifyIncluded ******************************** |
| * |
| * NAME |
| * isECOfBeforeModifyIncluded -- checks whether there is some |
| * ElementCollector on this BufferNode, that has BEFORE-MODIFY priority. |
| * |
| * SYNOPSIS |
| * bExist = isECOfBeforeModifyIncluded(nIgnoredSecurityId); |
| * |
| * FUNCTION |
| * checks each ElementCollector on this BufferNode, if all following |
| * conditions are satisfied, then returns true: |
| * 1. the ElementCollector's priority is BEFOREMODIFY; |
| * 2. the ElementCollector's securityId can't be ignored. |
| * otherwise, returns false. |
| * |
| * INPUTS |
| * nIgnoredSecurityId - the security Id to be ignored. If it equals |
| * to UNDEFINEDSECURITYID, then no security Id |
| * will be ignored. |
| * |
| * RESULT |
| * bExist - true if a match found, false otherwise |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| bool rc = false; |
| std::vector< const ElementCollector* >::const_iterator ii = m_vElementCollectors.begin(); |
| |
| for( ; ii != m_vElementCollectors.end() ; ++ii ) |
| { |
| ElementCollector* pElementCollector = (ElementCollector*)*ii; |
| |
| if ((nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID || |
| pElementCollector->getSecurityId() != nIgnoredSecurityId) && |
| (pElementCollector->getPriority() == cssxc::sax::ElementMarkPriority_BEFOREMODIFY)) |
| { |
| rc = true; |
| break; |
| } |
| } |
| |
| return rc; |
| } |
| |
| void BufferNode::setReceivedAll() |
| /****** BufferNode/setReceiveAll ********************************************* |
| * |
| * NAME |
| * setReceivedAll -- indicates that the element in this BufferNode has |
| * been compeletely bufferred. |
| * |
| * SYNOPSIS |
| * setReceivedAll(); |
| * |
| * FUNCTION |
| * sets the all-received flag and launches ElementCollector's notify |
| * process. |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * empty |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| m_bAllReceived = true; |
| elementCollectorNotify(); |
| } |
| |
| bool BufferNode::isAllReceived() const |
| { |
| return m_bAllReceived; |
| } |
| |
| void BufferNode::addElementCollector(const ElementCollector* pElementCollector) |
| /****** BufferNode/addElementCollector *************************************** |
| * |
| * NAME |
| * addElementCollector -- adds a new ElementCollector to this BufferNode. |
| * |
| * SYNOPSIS |
| * addElementCollector(pElementCollector); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pElementCollector - the ElementCollector to be added |
| * |
| * RESULT |
| * empty |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| m_vElementCollectors.push_back( pElementCollector ); |
| ((ElementCollector*)pElementCollector)->setBufferNode(this); |
| } |
| |
| void BufferNode::removeElementCollector(const ElementCollector* pElementCollector) |
| /****** BufferNode/removeElementCollector ************************************ |
| * |
| * NAME |
| * removeElementCollector -- removes an ElementCollector from this |
| * BufferNode. |
| * |
| * SYNOPSIS |
| * removeElementCollector(pElementCollector); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pElementCollector - the ElementCollector to be removed |
| * |
| * RESULT |
| * empty |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| std::vector< const ElementCollector* >::iterator ii = m_vElementCollectors.begin(); |
| |
| for( ; ii != m_vElementCollectors.end() ; ++ii ) |
| { |
| if( *ii == pElementCollector ) |
| { |
| m_vElementCollectors.erase( ii ); |
| ((ElementCollector*)pElementCollector)->setBufferNode(NULL); |
| break; |
| } |
| } |
| } |
| |
| ElementMark* BufferNode::getBlocker() const |
| { |
| return m_pBlocker; |
| } |
| |
| void BufferNode::setBlocker(const ElementMark* pBlocker) |
| /****** BufferNode/setBlocker ************************************************ |
| * |
| * NAME |
| * setBlocker -- adds a blocker to this BufferNode. |
| * |
| * SYNOPSIS |
| * setBlocker(pBlocker); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pBlocker - the new blocker to be attached |
| * |
| * RESULT |
| * empty |
| * |
| * NOTES |
| * Because there is only one blocker permited for a BufferNode, so the |
| * old blocker on this BufferNode, if there is one, will be overcasted. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| OSL_ASSERT(!(m_pBlocker != NULL && pBlocker != NULL)); |
| |
| m_pBlocker = (ElementMark*)pBlocker; |
| if (m_pBlocker != NULL) |
| { |
| m_pBlocker->setBufferNode(this); |
| } |
| } |
| |
| rtl::OUString BufferNode::printChildren() const |
| /****** BufferNode/printChildren ********************************************* |
| * |
| * NAME |
| * printChildren -- prints children information into a string. |
| * |
| * SYNOPSIS |
| * result = printChildren(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * result - the information string |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| rtl::OUString rc; |
| std::vector< const ElementCollector* >::const_iterator ii = m_vElementCollectors.begin(); |
| |
| for( ; ii != m_vElementCollectors.end() ; ++ii ) |
| { |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BufID=" )); |
| rc += rtl::OUString::valueOf((*ii)->getBufferId()); |
| |
| if (((ElementCollector*)(*ii))->getModify()) |
| { |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "[M]" )); |
| } |
| |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ",Pri=" )); |
| |
| switch (((ElementCollector*)(*ii))->getPriority()) |
| { |
| case cssxc::sax::ElementMarkPriority_BEFOREMODIFY: |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "BEFOREMODIFY" )); |
| break; |
| case cssxc::sax::ElementMarkPriority_AFTERMODIFY: |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "AFTERMODIFY" )); |
| break; |
| default: |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "UNKNOWN" )); |
| break; |
| } |
| |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "(" )); |
| /* |
| if (((ElementCollector*)(*ii))->isInternalNotificationSuppressed()) |
| { |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "*IN-Suppressed* " )); |
| } |
| */ |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( "SecID=" )); |
| rc += rtl::OUString::valueOf(((ElementCollector*)(*ii))->getSecurityId()); |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( ")" )); |
| rc += rtl::OUString( RTL_CONSTASCII_USTRINGPARAM( " " )); |
| } |
| |
| return rc; |
| } |
| |
| bool BufferNode::hasAnything() const |
| /****** BufferNode/hasAnything *********************************************** |
| * |
| * NAME |
| * hasAnything -- checks whether there is any ElementCollector or blocker |
| * on this BufferNode. |
| * |
| * SYNOPSIS |
| * bExist = hasAnything(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * bExist - true if there is, false otherwise. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| return (m_pBlocker != NULL || m_vElementCollectors.size() > 0); |
| } |
| |
| bool BufferNode::hasChildren() const |
| /****** BufferNode/hasChildren *********************************************** |
| * |
| * NAME |
| * hasChildren -- checks whether this BufferNode has any child |
| * BufferNode. |
| * |
| * SYNOPSIS |
| * bExist = hasChildren(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * bExist - true if there is, false otherwise. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| return (m_vChildren.size() > 0); |
| } |
| |
| std::vector< const BufferNode* >* BufferNode::getChildren() const |
| { |
| return new std::vector< const BufferNode* >( m_vChildren ); |
| } |
| |
| const BufferNode* BufferNode::getFirstChild() const |
| /****** BufferNode/getFirstChild ********************************************* |
| * |
| * NAME |
| * getFirstChild -- retrieves the first child BufferNode. |
| * |
| * SYNOPSIS |
| * child = getFirstChild(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * child - the first child BufferNode, or NULL if there is no child |
| * BufferNode. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| BufferNode* rc = NULL; |
| |
| if (m_vChildren.size() > 0) |
| { |
| rc = (BufferNode*)m_vChildren.front(); |
| } |
| |
| return (const BufferNode*)rc; |
| } |
| |
| void BufferNode::addChild(const BufferNode* pChild, sal_Int32 nPosition) |
| /****** BufferNode/addChild(pChild,nPosition) ******************************** |
| * |
| * NAME |
| * addChild -- inserts a child BufferNode at specific position. |
| * |
| * SYNOPSIS |
| * addChild(pChild, nPosition); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pChild - the child BufferNode to be added. |
| * nPosition - the position where the new child locates. |
| * |
| * RESULT |
| * empty |
| * |
| * NOTES |
| * If the nPosition is -1, then the new child BufferNode is appended |
| * at the end. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| if (nPosition == -1) |
| { |
| m_vChildren.push_back( pChild ); |
| } |
| else |
| { |
| std::vector< const BufferNode* >::iterator ii = m_vChildren.begin(); |
| ii += nPosition; |
| m_vChildren.insert(ii, pChild); |
| } |
| } |
| |
| void BufferNode::addChild(const BufferNode* pChild) |
| /****** BufferNode/addChild() ************************************************ |
| * |
| * NAME |
| * addChild -- add a new child BufferNode. |
| * |
| * SYNOPSIS |
| * addChild(pChild); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pChild - the child BufferNode to be added. |
| * |
| * RESULT |
| * empty |
| * |
| * NOTES |
| * The new child BufferNode is appended at the end. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| addChild(pChild, -1); |
| } |
| |
| void BufferNode::removeChild(const BufferNode* pChild) |
| /****** BufferNode/removeChild *********************************************** |
| * |
| * NAME |
| * removeChild -- removes a child BufferNode from the children list. |
| * |
| * SYNOPSIS |
| * removeChild(pChild); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pChild - the child BufferNode to be removed |
| * |
| * RESULT |
| * empty |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| std::vector< const BufferNode* >::iterator ii = m_vChildren.begin(); |
| |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| if( *ii == pChild ) |
| { |
| m_vChildren.erase( ii ); |
| break; |
| } |
| } |
| } |
| |
| sal_Int32 BufferNode::indexOfChild(const BufferNode* pChild) const |
| /****** BufferNode/indexOfChild ********************************************** |
| * |
| * NAME |
| * indexOfChild -- gets the index of a child BufferNode. |
| * |
| * SYNOPSIS |
| * index = indexOfChild(pChild); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pChild - the child BufferNode whose index to be gotten |
| * |
| * RESULT |
| * index - the index of that child BufferNode. If that child BufferNode |
| * is not found, -1 is returned. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| sal_Int32 nIndex = 0; |
| bool bFound = false; |
| |
| std::vector< const BufferNode * >::const_iterator ii = m_vChildren.begin(); |
| |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| if( *ii == pChild ) |
| { |
| bFound = true; |
| break; |
| } |
| nIndex++; |
| } |
| |
| if (!bFound ) |
| { |
| nIndex = -1; |
| } |
| |
| return nIndex; |
| } |
| |
| const BufferNode* BufferNode::childAt(sal_Int32 nIndex) const |
| /****** BufferNode/childAt *************************************************** |
| * |
| * NAME |
| * childAt -- retrieves the child BufferNode at specific possition. |
| * |
| * SYNOPSIS |
| * child = childAt(nIndex); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * nIndex - the index of the child BufferNode to be retrieved |
| * |
| * RESULT |
| * child - the child BufferNode at index position, or NULL if the index |
| * is out of the range of children. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| BufferNode* rc = NULL; |
| |
| if (nIndex < ((sal_Int32)m_vChildren.size()) && nIndex >= 0) |
| { |
| rc = (BufferNode*)m_vChildren[nIndex]; |
| } |
| |
| return (const BufferNode*)rc; |
| } |
| |
| const BufferNode* BufferNode::getParent() const |
| { |
| return m_pParent; |
| } |
| |
| void BufferNode::setParent(const BufferNode* pParent) |
| { |
| m_pParent = (BufferNode*)pParent; |
| } |
| |
| const BufferNode* BufferNode::getNextSibling() const |
| /****** BufferNode/getNextSibling ******************************************** |
| * |
| * NAME |
| * getNextSibling -- retrieves the next sibling BufferNode. |
| * |
| * SYNOPSIS |
| * sibling = getNextSibling(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * sibling - the next sibling BufferNode, or NULL if there is none. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| BufferNode* rc = NULL; |
| |
| if (m_pParent != NULL) |
| { |
| rc = (BufferNode*)m_pParent->getNextChild(this); |
| } |
| |
| return (const BufferNode*)rc; |
| } |
| |
| const BufferNode* BufferNode::isAncestor(const BufferNode* pDescendant) const |
| /****** BufferNode/isAncestor ************************************************ |
| * |
| * NAME |
| * isAncestor -- checks whether this BufferNode is an ancestor of another |
| * BufferNode. |
| * |
| * SYNOPSIS |
| * bIs = isAncestor(pDescendant); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pDescendant - the BufferNode to be checked as a descendant |
| * |
| * RESULT |
| * bIs - true if this BufferNode is an ancestor of the pDescendant, |
| * false otherwise. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| BufferNode* rc = NULL; |
| |
| if (pDescendant != NULL) |
| { |
| std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin(); |
| |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| BufferNode* pChild = (BufferNode*)*ii; |
| |
| if (pChild == pDescendant) |
| { |
| rc = pChild; |
| break; |
| } |
| |
| if (pChild->isAncestor(pDescendant) != NULL) |
| { |
| rc = pChild; |
| break; |
| } |
| } |
| } |
| |
| return (const BufferNode*)rc; |
| } |
| |
| bool BufferNode::isPrevious(const BufferNode* pFollowing) const |
| /****** BufferNode/isPrevious ************************************************ |
| * |
| * NAME |
| * isPrevious -- checks whether this BufferNode is ahead of another |
| * BufferNode in the tree order. |
| * |
| * SYNOPSIS |
| * bIs = isPrevious(pFollowing); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pFollowing - the BufferNode to be checked as a following |
| * |
| * RESULT |
| * bIs - true if this BufferNode is ahead in the tree order, false |
| * otherwise. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| bool rc = false; |
| |
| BufferNode* pNextBufferNode = (BufferNode*)getNextNodeByTreeOrder(); |
| while (pNextBufferNode != NULL) |
| { |
| if (pNextBufferNode == pFollowing) |
| { |
| rc = true; |
| break; |
| } |
| |
| pNextBufferNode = (BufferNode*)(pNextBufferNode->getNextNodeByTreeOrder()); |
| } |
| |
| return rc; |
| } |
| |
| const BufferNode* BufferNode::getNextNodeByTreeOrder() const |
| /****** BufferNode/getNextNodeByTreeOrder ************************************ |
| * |
| * NAME |
| * getNextNodeByTreeOrder -- retrieves the next BufferNode in the tree |
| * order. |
| * |
| * SYNOPSIS |
| * next = getNextNodeByTreeOrder(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * next - the BufferNode following this BufferNode in the tree order, |
| * or NULL if there is none. |
| * |
| * NOTES |
| * The "next" node in tree order is defined as: |
| * 1. If a node has children, then the first child is; |
| * 2. otherwise, if it has a following sibling, then this sibling node is; |
| * 3. otherwise, if it has a parent node, the the parent's next sibling |
| * node is; |
| * 4. otherwise, no "next" node exists. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| /* |
| * If this buffer node has m_vChildren, then return the first |
| * child. |
| */ |
| if (hasChildren()) |
| { |
| return getFirstChild(); |
| } |
| |
| /* |
| * Otherwise, it this buffer node has a following sibling, |
| * then return that sibling. |
| */ |
| BufferNode* pNextSibling = (BufferNode*)getNextSibling(); |
| if (pNextSibling != NULL) |
| { |
| return pNextSibling; |
| } |
| |
| /* |
| * Otherwise, it this buffer node has parent, then return |
| * its parent's following sibling. |
| */ |
| BufferNode* pNode = (BufferNode*)this; |
| BufferNode* pParent; |
| BufferNode* pNextSiblingParent = NULL; |
| |
| do |
| { |
| if (pNode == NULL) |
| { |
| break; |
| } |
| |
| pParent = (BufferNode*)pNode->getParent(); |
| if (pParent != NULL) |
| { |
| pNextSiblingParent = (BufferNode*)pParent->getNextSibling(); |
| } |
| pNode = pParent; |
| |
| }while (pNextSiblingParent == NULL); |
| |
| return pNextSiblingParent; |
| } |
| |
| cssu::Reference< cssxw::XXMLElementWrapper > BufferNode::getXMLElement() const |
| { |
| return m_xXMLElement; |
| } |
| |
| void BufferNode::setXMLElement( const cssu::Reference< cssxw::XXMLElementWrapper >& xXMLElement ) |
| { |
| m_xXMLElement = xXMLElement; |
| } |
| |
| void BufferNode::notifyBranch() |
| /****** BufferNode/notifyBranch ********************************************** |
| * |
| * NAME |
| * notifyBranch -- notifies each BufferNode in the branch of this |
| * BufferNode in the tree order. |
| * |
| * SYNOPSIS |
| * notifyBranch(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * empty |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin(); |
| |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| BufferNode* pBufferNode = (BufferNode*)*ii; |
| pBufferNode->elementCollectorNotify(); |
| pBufferNode->notifyBranch(); |
| } |
| } |
| |
| void BufferNode::notifyAncestor() |
| /****** BufferNode/notifyAncestor ******************************************** |
| * |
| * NAME |
| * notifyAncestor -- notifies each ancestor BufferNode through the parent |
| * link. |
| * |
| * SYNOPSIS |
| * notifyAncestor(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * empty |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| BufferNode* pParent = m_pParent; |
| while (pParent != NULL) |
| { |
| pParent->notifyAncestor(); |
| pParent = (BufferNode*)pParent->getParent(); |
| } |
| } |
| |
| void BufferNode::elementCollectorNotify() |
| /****** BufferNode/elementCollectorNotify ************************************ |
| * |
| * NAME |
| * elementCollectorNotify -- notifies this BufferNode. |
| * |
| * SYNOPSIS |
| * elementCollectorNotify(); |
| * |
| * FUNCTION |
| * Notifies this BufferNode if the notification is not suppressed. |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * child - the first child BufferNode, or NULL if there is no child |
| * BufferNode. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| if (m_vElementCollectors.size()>0) |
| { |
| cssxc::sax::ElementMarkPriority nMaxPriority = cssxc::sax::ElementMarkPriority_MINIMUM; |
| cssxc::sax::ElementMarkPriority nPriority; |
| |
| /* |
| * get the max priority among ElementCollectors on this BufferNode |
| */ |
| std::vector< const ElementCollector* >::const_iterator ii = m_vElementCollectors.begin(); |
| for( ; ii != m_vElementCollectors.end() ; ++ii ) |
| { |
| ElementCollector* pElementCollector = (ElementCollector*)*ii; |
| nPriority = pElementCollector->getPriority(); |
| if (nPriority > nMaxPriority) |
| { |
| nMaxPriority = nPriority; |
| } |
| } |
| |
| std::vector< const ElementCollector* > vElementCollectors( m_vElementCollectors ); |
| ii = vElementCollectors.begin(); |
| |
| for( ; ii != vElementCollectors.end() ; ++ii ) |
| { |
| ElementCollector* pElementCollector = (ElementCollector*)*ii; |
| nPriority = pElementCollector->getPriority(); |
| bool bToModify = pElementCollector->getModify(); |
| |
| /* |
| * Only ElementCollector with the max priority can |
| * perform notify operation. |
| * Moreover, if any blocker exists in the subtree of |
| * this BufferNode, this ElementCollector can't do notify |
| * unless its priority is BEFOREMODIFY. |
| */ |
| if (nPriority == nMaxPriority && |
| (nPriority == cssxc::sax::ElementMarkPriority_BEFOREMODIFY || |
| !isBlockerInSubTreeIncluded(pElementCollector->getSecurityId()))) |
| { |
| /* |
| * If this ElementCollector will modify the bufferred element, then |
| * special attention must be paid. |
| * |
| * If there is any ElementCollector in the subtree or any ancestor |
| * ElementCollector with PRI_BEFPREMODIFY priority, this |
| * ElementCollector can't perform notify operation, otherwise, it |
| * will destroy the bufferred element, in turn, ElementCollectors |
| * mentioned above can't perform their mission. |
| */ |
| //if (!(nMaxPriority == cssxc::sax::ElementMarkPriority_PRI_MODIFY && |
| if (!(bToModify && |
| (isECInSubTreeIncluded(pElementCollector->getSecurityId()) || |
| isECOfBeforeModifyInAncestorIncluded(pElementCollector->getSecurityId())) |
| )) |
| { |
| pElementCollector->notifyListener(); |
| } |
| } |
| } |
| } |
| } |
| |
| bool BufferNode::isECInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const |
| /****** BufferNode/isECInSubTreeIncluded ************************************* |
| * |
| * NAME |
| * isECInSubTreeIncluded -- checks whether there is any ElementCollector |
| * in the branch of this BufferNode. |
| * |
| * SYNOPSIS |
| * bExist = isECInSubTreeIncluded(nIgnoredSecurityId); |
| * |
| * FUNCTION |
| * checks each BufferNode in the branch of this BufferNode, if there is |
| * an ElementCollector whose signatureId is not ignored, then return |
| * true, otherwise, false returned. |
| * |
| * INPUTS |
| * nIgnoredSecurityId - the security Id to be ignored. If it equals |
| * to UNDEFINEDSECURITYID, then no security Id |
| * will be ignored. |
| * |
| * RESULT |
| * bExist - true if a match found, false otherwise. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| bool rc = false; |
| |
| std::vector< const ElementCollector* >::const_iterator jj = m_vElementCollectors.begin(); |
| |
| for( ; jj != m_vElementCollectors.end() ; ++jj ) |
| { |
| ElementCollector* pElementCollector = (ElementCollector*)*jj; |
| if (nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID || |
| pElementCollector->getSecurityId() != nIgnoredSecurityId) |
| { |
| rc = true; |
| break; |
| } |
| } |
| |
| if ( !rc ) |
| { |
| std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin(); |
| |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| BufferNode* pBufferNode = (BufferNode*)*ii; |
| |
| if ( pBufferNode->isECInSubTreeIncluded(nIgnoredSecurityId)) |
| { |
| rc = true; |
| break; |
| } |
| } |
| } |
| |
| return rc; |
| } |
| |
| bool BufferNode::isECOfBeforeModifyInAncestorIncluded(sal_Int32 nIgnoredSecurityId) const |
| /****** BufferNode/isECOfBeforeModifyInAncestorIncluded ********************** |
| * |
| * NAME |
| * isECOfBeforeModifyInAncestorIncluded -- checks whether there is some |
| * ancestor BufferNode which has ElementCollector with PRI_BEFPREMODIFY |
| * priority. |
| * |
| * SYNOPSIS |
| * bExist = isECOfBeforeModifyInAncestorIncluded(nIgnoredSecurityId); |
| * |
| * FUNCTION |
| * checks each ancestor BufferNode through the parent link, if there is |
| * an ElementCollector with PRI_BEFPREMODIFY priority and its |
| * signatureId is not ignored, then return true, otherwise, false |
| * returned. |
| * |
| * INPUTS |
| * nIgnoredSecurityId - the security Id to be ignored. If it equals |
| * to UNDEFINEDSECURITYID, then no security Id |
| * will be ignored. |
| * |
| * RESULT |
| * bExist - true if a match found, false otherwise. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| bool rc = false; |
| |
| BufferNode* pParentNode = m_pParent; |
| while (pParentNode != NULL) |
| { |
| if (pParentNode->isECOfBeforeModifyIncluded(nIgnoredSecurityId)) |
| { |
| rc = true; |
| break; |
| } |
| |
| pParentNode = (BufferNode*)pParentNode->getParent(); |
| } |
| |
| return rc; |
| } |
| |
| bool BufferNode::isBlockerInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const |
| /****** BufferNode/isBlockerInSubTreeIncluded ******************************** |
| * |
| * NAME |
| * isBlockerInSubTreeIncluded -- checks whether there is some BufferNode |
| * which has blocker on it |
| * |
| * SYNOPSIS |
| * bExist = isBlockerInSubTreeIncluded(nIgnoredSecurityId); |
| * |
| * FUNCTION |
| * checks each BufferNode in the branch of this BufferNode, if one has |
| * a blocker on it, and the blocker's securityId is not ignored, then |
| * returns true; otherwise, false returns. |
| * |
| * INPUTS |
| * nIgnoredSecurityId - the security Id to be ignored. If it equals |
| * to UNDEFINEDSECURITYID, then no security Id |
| * will be ignored. |
| * |
| * RESULT |
| * bExist - true if a match found, false otherwise. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| bool rc = false; |
| |
| std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin(); |
| |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| BufferNode* pBufferNode = (BufferNode*)*ii; |
| ElementMark* pBlocker = pBufferNode->getBlocker(); |
| |
| if (pBlocker != NULL && |
| (nIgnoredSecurityId == cssxc::sax::ConstOfSecurityId::UNDEFINEDSECURITYID || |
| pBlocker->getSecurityId() != nIgnoredSecurityId )) |
| { |
| rc = true; |
| break; |
| } |
| |
| if (rc || pBufferNode->isBlockerInSubTreeIncluded(nIgnoredSecurityId)) |
| { |
| rc = true; |
| break; |
| } |
| } |
| |
| return rc; |
| } |
| |
| const BufferNode* BufferNode::getNextChild(const BufferNode* pChild) const |
| /****** BufferNode/getNextChild ********************************************** |
| * |
| * NAME |
| * getNextChild -- get the next child BufferNode. |
| * |
| * SYNOPSIS |
| * nextChild = getNextChild(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * pChild - the child BufferNode whose next node is retrieved. |
| * |
| * RESULT |
| * nextChild - the next child BufferNode after the pChild, or NULL if |
| * there is none. |
| * |
| * HISTORY |
| * 05.01.2004 - implemented |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| BufferNode* rc = NULL; |
| bool bChildFound = false; |
| |
| std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin(); |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| if (bChildFound) |
| { |
| rc = (BufferNode*)*ii; |
| break; |
| } |
| |
| if( *ii == pChild ) |
| { |
| bChildFound = true; |
| } |
| } |
| |
| return (const BufferNode*)rc; |
| } |
| |
| |
| void BufferNode::freeAllChildren() |
| /****** BufferNode/freeAllChildren ******************************************* |
| * |
| * NAME |
| * freeAllChildren -- free all his child BufferNode. |
| * |
| * SYNOPSIS |
| * freeAllChildren(); |
| * |
| * FUNCTION |
| * see NAME |
| * |
| * INPUTS |
| * empty |
| * |
| * RESULT |
| * empty |
| * |
| * HISTORY |
| * 30.03.2004 - the correct the memory leak bug |
| * |
| * AUTHOR |
| * Michael Mi |
| * Email: michael.mi@sun.com |
| ******************************************************************************/ |
| { |
| std::vector< const BufferNode* >::const_iterator ii = m_vChildren.begin(); |
| for( ; ii != m_vChildren.end() ; ++ii ) |
| { |
| BufferNode *pChild = (BufferNode *)(*ii); |
| pChild->freeAllChildren(); |
| delete pChild; |
| } |
| |
| m_vChildren.clear(); |
| } |
