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