1290 lines
32 KiB
C++
1290 lines
32 KiB
C++
/*************************************************************************
|
|
*
|
|
* OpenOffice.org - a multi-platform office productivity suite
|
|
*
|
|
* $RCSfile: buffernode.cxx,v $
|
|
*
|
|
* $Revision: 1.5 $
|
|
*
|
|
* last change: $Author: ihi $ $Date: 2007-04-17 10:16:49 $
|
|
*
|
|
* The Contents of this file are made available subject to
|
|
* the terms of GNU Lesser General Public License Version 2.1.
|
|
*
|
|
*
|
|
* GNU Lesser General Public License Version 2.1
|
|
* =============================================
|
|
* Copyright 2005 by Sun Microsystems, Inc.
|
|
* 901 San Antonio Road, Palo Alto, CA 94303, USA
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License version 2.1, as published by the Free Software Foundation.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston,
|
|
* MA 02111-1307 USA
|
|
*
|
|
************************************************************************/
|
|
|
|
// MARKER(update_precomp.py): autogen include statement, do not remove
|
|
#include "precompiled_xmlsecurity.hxx"
|
|
|
|
#include "elementmark.hxx"
|
|
#include "elementcollector.hxx"
|
|
#include "buffernode.hxx"
|
|
|
|
#ifndef _COM_SUN_STAR_XML_CRYPTO_SAX_CONSTOFSECURITYID_HPP_
|
|
#include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp>
|
|
#endif
|
|
|
|
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();
|
|
}
|