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