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