buffernode.cxx

Go to the documentation of this file.

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
 * This file is part of the LibreOffice project.
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 *
 * This file incorporates work covered by the following license notice:
 *
 *   Licensed to the Apache Software Foundation (ASF) under one or more
 *   contributor license agreements. See the NOTICE file distributed
 *   with this work for additional information regarding copyright
 *   ownership. The ASF licenses this file to you under the Apache
 *   License, Version 2.0 (the "License"); you may not use this file
 *   except in compliance with the License. You may obtain a copy of
 *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
 */
 
 
#include "elementmark.hxx"
#include "elementcollector.hxx"
#include "buffernode.hxx"
#include <com/sun/star/xml/crypto/sax/ConstOfSecurityId.hpp>
#include <osl/diagnose.h>
#include <rtl/ustrbuf.hxx>
#include <utility>
 
BufferNode::BufferNode( css::uno::Reference< css::xml::wrapper::XXMLElementWrapper > xXMLElement )
    :m_pParent(nullptr),
     m_pBlocker(nullptr),
     m_bAllReceived(false),
     m_xXMLElement(std::move(xXMLElement))
{
}
 
bool BufferNode::isECOfBeforeModifyIncluded(sal_Int32 nIgnoredSecurityId) const
/****** BufferNode/isECOfBeforeModifyIncluded ********************************
 *
 *   NAME
 *  isECOfBeforeModifyIncluded -- checks whether there is some
 *  ElementCollector on this BufferNode, that has BEFORE-MODIFY priority.
 *
 *   SYNOPSIS
 *  bExist = isECOfBeforeModifyIncluded(nIgnoredSecurityId);
 *
 *   FUNCTION
 *  checks each ElementCollector on this BufferNode, if all following
 *  conditions are satisfied, then returns true:
 *  1. the ElementCollector's priority is BEFOREMODIFY;
 *  2. the ElementCollector's securityId can't be ignored.
 *  otherwise, returns false.
 *
 *   INPUTS
 *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
 *                          to UNDEFINEDSECURITYID, then no security Id
 *                          will be ignored.
 *
 *   RESULT
 *  bExist - true if a match found, false otherwise
 ******************************************************************************/
{
    return std::any_of(m_vElementCollectors.cbegin(), m_vElementCollectors.cend(),
        [nIgnoredSecurityId](const ElementCollector* pElementCollector) {
            return (nIgnoredSecurityId == css::xml::crypto::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
                    pElementCollector->getSecurityId() != nIgnoredSecurityId) &&
                   (pElementCollector->getPriority() == css::xml::crypto::sax::ElementMarkPriority_BEFOREMODIFY);
        });
}
 
void BufferNode::setReceivedAll()
/****** BufferNode/setReceiveAll *********************************************
 *
 *   NAME
 *  setReceivedAll -- indicates that the element in this BufferNode has
 *  been completely buffered.
 *
 *   SYNOPSIS
 *  setReceivedAll();
 *
 *   FUNCTION
 *  sets the all-received flag and launches ElementCollector's notify
 *  process.
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  empty
 ******************************************************************************/
{
    m_bAllReceived = true;
    elementCollectorNotify();
}
 
 
void BufferNode::addElementCollector(const ElementCollector* pElementCollector)
/****** BufferNode/addElementCollector ***************************************
 *
 *   NAME
 *  addElementCollector -- adds a new ElementCollector to this BufferNode.
 *
 *   SYNOPSIS
 *  addElementCollector(pElementCollector);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pElementCollector - the ElementCollector to be added
 *
 *   RESULT
 *  empty
 ******************************************************************************/
{
    m_vElementCollectors.push_back( pElementCollector );
    const_cast<ElementCollector*>(pElementCollector)->setBufferNode(this);
}
 
void BufferNode::removeElementCollector(const ElementCollector* pElementCollector)
/****** BufferNode/removeElementCollector ************************************
 *
 *   NAME
 *  removeElementCollector -- removes an ElementCollector from this
 *  BufferNode.
 *
 *   SYNOPSIS
 *  removeElementCollector(pElementCollector);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pElementCollector - the ElementCollector to be removed
 *
 *   RESULT
 *  empty
 ******************************************************************************/
{
    auto ii = std::find(m_vElementCollectors.begin(), m_vElementCollectors.end(), pElementCollector);
    if (ii != m_vElementCollectors.end())
    {
        m_vElementCollectors.erase( ii );
        const_cast<ElementCollector*>(pElementCollector)->setBufferNode(nullptr);
    }
}
 
 
void BufferNode::setBlocker(const ElementMark* pBlocker)
/****** BufferNode/setBlocker ************************************************
 *
 *   NAME
 *  setBlocker -- adds a blocker to this BufferNode.
 *
 *   SYNOPSIS
 *  setBlocker(pBlocker);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pBlocker - the new blocker to be attached
 *
 *   RESULT
 *  empty
 *
 *   NOTES
 *  Because there is only one blocker permitted for a BufferNode, so the
 *  old blocker on this BufferNode, if there is one, will be overcasted.
 ******************************************************************************/
{
    OSL_ASSERT(!(m_pBlocker != nullptr && pBlocker != nullptr));
 
    m_pBlocker = const_cast<ElementMark*>(pBlocker);
    if (m_pBlocker != nullptr)
    {
        m_pBlocker->setBufferNode(this);
    }
}
 
OUString BufferNode::printChildren() const
/****** BufferNode/printChildren *********************************************
 *
 *   NAME
 *  printChildren -- prints children information into a string.
 *
 *   SYNOPSIS
 *  result = printChildren();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  result - the information string
 ******************************************************************************/
{
    OUStringBuffer rc;
 
    for( const ElementCollector* ii : m_vElementCollectors )
    {
        rc.append("BufID=" + OUString::number(ii->getBufferId()));
 
        if (ii->getModify())
        {
            rc.append("[M]");
        }
 
        rc.append(",Pri=");
 
        switch (ii->getPriority())
        {
            case css::xml::crypto::sax::ElementMarkPriority_BEFOREMODIFY:
                rc.append("BEFOREMODIFY");
                break;
            case css::xml::crypto::sax::ElementMarkPriority_AFTERMODIFY:
                rc.append("AFTERMODIFY");
                break;
            default:
                rc.append("UNKNOWN");
                break;
        }
 
        rc.append("(SecID=" + OUString::number(ii->getSecurityId()) + ") ");
    }
 
    return rc.makeStringAndClear();
}
 
bool BufferNode::hasAnything() const
/****** BufferNode/hasAnything ***********************************************
 *
 *   NAME
 *  hasAnything -- checks whether there is any ElementCollector or blocker
 *  on this BufferNode.
 *
 *   SYNOPSIS
 *  bExist = hasAnything();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  bExist - true if there is, false otherwise.
 ******************************************************************************/
{
    return (m_pBlocker || !m_vElementCollectors.empty());
}
 
bool BufferNode::hasChildren() const
/****** BufferNode/hasChildren ***********************************************
 *
 *   NAME
 *  hasChildren -- checks whether this BufferNode has any child
 *  BufferNode.
 *
 *   SYNOPSIS
 *  bExist = hasChildren();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  bExist - true if there is, false otherwise.
 ******************************************************************************/
{
    return (!m_vChildren.empty());
}
 
std::vector< std::unique_ptr<BufferNode> > const & BufferNode::getChildren() const
{
    return m_vChildren;
}
 
std::vector< std::unique_ptr<BufferNode> > BufferNode::releaseChildren()
{
    return std::move(m_vChildren);
}
 
const BufferNode* BufferNode::getFirstChild() const
/****** BufferNode/getFirstChild *********************************************
 *
 *   NAME
 *  getFirstChild -- retrieves the first child BufferNode.
 *
 *   SYNOPSIS
 *  child = getFirstChild();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  child - the first child BufferNode, or NULL if there is no child
 *          BufferNode.
 ******************************************************************************/
{
    BufferNode* rc = nullptr;
 
    if (!m_vChildren.empty())
    {
        rc = m_vChildren.front().get();
    }
 
    return rc;
}
 
void BufferNode::addChild(std::unique_ptr<BufferNode> pChild, sal_Int32 nPosition)
/****** BufferNode/addChild(pChild,nPosition) ********************************
 *
 *   NAME
 *  addChild -- inserts a child BufferNode at specific position.
 *
 *   SYNOPSIS
 *  addChild(pChild, nPosition);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pChild -    the child BufferNode to be added.
 *  nPosition - the position where the new child locates.
 *
 *   RESULT
 *  empty
 *
 *   NOTES
 *  If the nPosition is -1, then the new child BufferNode is appended
 *  at the end.
 ******************************************************************************/
{
    if (nPosition == -1)
    {
        m_vChildren.push_back( std::move(pChild) );
    }
    else
    {
        m_vChildren.insert(m_vChildren.begin() + nPosition, std::move(pChild));
    }
}
 
void BufferNode::addChild(std::unique_ptr<BufferNode> pChild)
/****** BufferNode/addChild() ************************************************
 *
 *   NAME
 *  addChild -- add a new child BufferNode.
 *
 *   SYNOPSIS
 *  addChild(pChild);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pChild -    the child BufferNode to be added.
 *
 *   RESULT
 *  empty
 *
 *   NOTES
 *  The new child BufferNode is appended at the end.
 ******************************************************************************/
{
    addChild(std::move(pChild), -1);
}
 
void BufferNode::removeChild(const BufferNode* pChild)
/****** BufferNode/removeChild ***********************************************
 *
 *   NAME
 *  removeChild -- removes and deletes a child BufferNode from the children list.
 *
 *   SYNOPSIS
 *  removeChild(pChild);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pChild - the child BufferNode to be removed
 *
 *   RESULT
 *  empty
 ******************************************************************************/
{
    auto ii = std::find_if(m_vChildren.begin(), m_vChildren.end(),
                [pChild] (const std::unique_ptr<BufferNode>& i)
                { return i.get() == pChild; });
    if (ii != m_vChildren.end())
        m_vChildren.erase( ii );
}
 
sal_Int32 BufferNode::indexOfChild(const BufferNode* pChild) const
/****** BufferNode/indexOfChild **********************************************
 *
 *   NAME
 *  indexOfChild -- gets the index of a child BufferNode.
 *
 *   SYNOPSIS
 *  index = indexOfChild(pChild);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pChild - the child BufferNode whose index to be gotten
 *
 *   RESULT
 *  index - the index of that child BufferNode. If that child BufferNode
 *          is not found, -1 is returned.
 ******************************************************************************/
{
    auto ii = std::find_if(m_vChildren.begin(), m_vChildren.end(),
            [pChild] (const std::unique_ptr<BufferNode>& i)
            { return i.get() == pChild; });
    if (ii == m_vChildren.end())
        return -1;
 
    return std::distance(m_vChildren.begin(), ii);
}
 
 
void BufferNode::setParent(const BufferNode* pParent)
{
    m_pParent = const_cast<BufferNode*>(pParent);
}
 
const BufferNode* BufferNode::getNextSibling() const
/****** BufferNode/getNextSibling ********************************************
 *
 *   NAME
 *  getNextSibling -- retrieves the next sibling BufferNode.
 *
 *   SYNOPSIS
 *  sibling = getNextSibling();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  sibling - the next sibling BufferNode, or NULL if there is none.
 ******************************************************************************/
{
    BufferNode* rc = nullptr;
 
    if (m_pParent != nullptr)
    {
        rc = const_cast<BufferNode*>(m_pParent->getNextChild(this));
    }
 
    return rc;
}
 
const BufferNode* BufferNode::isAncestor(const BufferNode* pDescendant) const
/****** BufferNode/isAncestor ************************************************
 *
 *   NAME
 *  isAncestor -- checks whether this BufferNode is an ancestor of another
 *  BufferNode.
 *
 *   SYNOPSIS
 *  bIs = isAncestor(pDescendant);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pDescendant -   the BufferNode to be checked as a descendant
 *
 *   RESULT
 *  bIs -   true if this BufferNode is an ancestor of the pDescendant,
 *          false otherwise.
 ******************************************************************************/
{
    BufferNode* rc = nullptr;
 
    if (pDescendant != nullptr)
    {
        auto ii = std::find_if(m_vChildren.cbegin(), m_vChildren.cend(),
            [&pDescendant](const std::unique_ptr<BufferNode>& pChild) {
                return (pChild.get() == pDescendant) || (pChild->isAncestor(pDescendant) != nullptr);
            });
 
        if (ii != m_vChildren.end())
            rc = ii->get();
    }
 
    return rc;
}
 
bool BufferNode::isPrevious(const BufferNode* pFollowing) const
/****** BufferNode/isPrevious ************************************************
 *
 *   NAME
 *  isPrevious -- checks whether this BufferNode is ahead of another
 *  BufferNode in the tree order.
 *
 *   SYNOPSIS
 *  bIs = isPrevious(pFollowing);
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pFollowing -    the BufferNode to be checked as a following
 *
 *   RESULT
 *  bIs -   true if this BufferNode is ahead in the tree order, false
 *          otherwise.
 ******************************************************************************/
{
    bool rc = false;
 
    BufferNode* pNextBufferNode = const_cast<BufferNode*>(getNextNodeByTreeOrder());
    while (pNextBufferNode != nullptr)
    {
        if (pNextBufferNode == pFollowing)
        {
            rc = true;
            break;
        }
 
        pNextBufferNode = const_cast<BufferNode*>(pNextBufferNode->getNextNodeByTreeOrder());
    }
 
    return rc;
}
 
const BufferNode* BufferNode::getNextNodeByTreeOrder() const
/****** BufferNode/getNextNodeByTreeOrder ************************************
 *
 *   NAME
 *  getNextNodeByTreeOrder -- retrieves the next BufferNode in the tree
 *  order.
 *
 *   SYNOPSIS
 *  next = getNextNodeByTreeOrder();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  next -  the BufferNode following this BufferNode in the tree order,
 *          or NULL if there is none.
 *
 *   NOTES
 *  The "next" node in tree order is defined as:
 *  1. If a node has children, then the first child is;
 *  2. otherwise, if it has a following sibling, then this sibling node is;
 *  3. otherwise, if it has a parent node, the parent's next sibling
 *     node is;
 *  4. otherwise, no "next" node exists.
 ******************************************************************************/
{
    /*
     * If this buffer node has m_vChildren, then return the first
     * child.
     */
    if (hasChildren())
    {
        return getFirstChild();
    }
 
    /*
     * Otherwise, it this buffer node has a following sibling,
     * then return that sibling.
     */
    BufferNode* pNextSibling = const_cast<BufferNode*>(getNextSibling());
    if (pNextSibling != nullptr)
    {
        return pNextSibling;
    }
 
    /*
     * Otherwise, it this buffer node has parent, then return
     * its parent's following sibling.
     */
    BufferNode* pNode = const_cast<BufferNode*>(this);
    BufferNode* pParent;
    BufferNode* pNextSiblingParent = nullptr;
 
    do
    {
        if (pNode == nullptr)
        {
            break;
        }
 
        pParent = const_cast<BufferNode*>(pNode->getParent());
        if (pParent != nullptr)
        {
            pNextSiblingParent = const_cast<BufferNode*>(pParent->getNextSibling());
        }
        pNode = pParent;
 
    } while (pNextSiblingParent == nullptr);
 
    return pNextSiblingParent;
}
 
 
void BufferNode::setXMLElement( const css::uno::Reference< css::xml::wrapper::XXMLElementWrapper >& xXMLElement )
{
    m_xXMLElement = xXMLElement;
}
 
void BufferNode::notifyBranch()
/****** BufferNode/notifyBranch **********************************************
 *
 *   NAME
 *  notifyBranch -- notifies each BufferNode in the branch of this
 *  BufferNode in the tree order.
 *
 *   SYNOPSIS
 *  notifyBranch();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  empty
 ******************************************************************************/
{
    for( std::unique_ptr<BufferNode>& pBufferNode : m_vChildren )
    {
        pBufferNode->elementCollectorNotify();
        pBufferNode->notifyBranch();
    }
}
 
void BufferNode::elementCollectorNotify()
/****** BufferNode/elementCollectorNotify ************************************
 *
 *   NAME
 *  elementCollectorNotify -- notifies this BufferNode.
 *
 *   SYNOPSIS
 *  elementCollectorNotify();
 *
 *   FUNCTION
 *  Notifies this BufferNode if the notification is not suppressed.
 *
 *   INPUTS
 *  empty
 *
 *   RESULT
 *  child - the first child BufferNode, or NULL if there is no child
 *          BufferNode.
 ******************************************************************************/
{
    if (m_vElementCollectors.empty())
        return;
 
    css::xml::crypto::sax::ElementMarkPriority nMaxPriority = css::xml::crypto::sax::ElementMarkPriority_MINIMUM;
    css::xml::crypto::sax::ElementMarkPriority nPriority;
 
    /*
     * get the max priority among ElementCollectors on this BufferNode
     */
    for( const ElementCollector* pElementCollector : m_vElementCollectors )
    {
        nPriority = pElementCollector->getPriority();
        if (nPriority > nMaxPriority)
        {
            nMaxPriority = nPriority;
        }
    }
 
    std::vector< const ElementCollector* > vElementCollectors( m_vElementCollectors );
 
    for( const ElementCollector* ii : vElementCollectors )
    {
        ElementCollector* pElementCollector = const_cast<ElementCollector*>(ii);
        nPriority = pElementCollector->getPriority();
        bool bToModify = pElementCollector->getModify();
 
        /*
         * Only ElementCollector with the max priority can
         * perform notify operation.
         * Moreover, if any blocker exists in the subtree of
         * this BufferNode, this ElementCollector can't do notify
         * unless its priority is BEFOREMODIFY.
         */
        if (nPriority == nMaxPriority &&
            (nPriority == css::xml::crypto::sax::ElementMarkPriority_BEFOREMODIFY ||
             !isBlockerInSubTreeIncluded(pElementCollector->getSecurityId())))
        {
            /*
             * If this ElementCollector will modify the buffered element, then
             * special attention must be paid.
             *
             * If there is any ElementCollector in the subtree or any ancestor
             * ElementCollector with PRI_BEFPREMODIFY priority, this
             * ElementCollector can't perform notify operation, otherwise, it
             * will destroy the buffered element, in turn, ElementCollectors
             * mentioned above can't perform their mission.
             */
            //if (!(nMaxPriority == css::xml::crypto::sax::ElementMarkPriority_PRI_MODIFY &&
            if (!(bToModify &&
                 (isECInSubTreeIncluded(pElementCollector->getSecurityId()) ||
                  isECOfBeforeModifyInAncestorIncluded(pElementCollector->getSecurityId()))
               ))
            {
                pElementCollector->notifyListener();
            }
        }
    }
}
 
bool BufferNode::isECInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const
/****** BufferNode/isECInSubTreeIncluded *************************************
 *
 *   NAME
 *  isECInSubTreeIncluded -- checks whether there is any ElementCollector
 *  in the branch of this BufferNode.
 *
 *   SYNOPSIS
 *  bExist = isECInSubTreeIncluded(nIgnoredSecurityId);
 *
 *   FUNCTION
 *  checks each BufferNode in the branch of this BufferNode, if there is
 *  an ElementCollector whose signatureId is not ignored, then return
 *  true, otherwise, false returned.
 *
 *   INPUTS
 *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
 *                          to UNDEFINEDSECURITYID, then no security Id
 *                          will be ignored.
 *
 *   RESULT
 *  bExist - true if a match found, false otherwise.
 ******************************************************************************/
{
    bool rc = std::any_of(m_vElementCollectors.begin(), m_vElementCollectors.end(),
        [nIgnoredSecurityId](const ElementCollector* pElementCollector) {
            return nIgnoredSecurityId == css::xml::crypto::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
                pElementCollector->getSecurityId() != nIgnoredSecurityId;
    });
 
    if ( !rc )
    {
        rc = std::any_of(m_vChildren.begin(), m_vChildren.end(),
            [nIgnoredSecurityId](const std::unique_ptr<BufferNode>& pBufferNode) {
                return pBufferNode->isECInSubTreeIncluded(nIgnoredSecurityId);
        });
    }
 
    return rc;
}
 
bool BufferNode::isECOfBeforeModifyInAncestorIncluded(sal_Int32 nIgnoredSecurityId) const
/****** BufferNode/isECOfBeforeModifyInAncestorIncluded **********************
 *
 *   NAME
 *  isECOfBeforeModifyInAncestorIncluded -- checks whether there is some
 *  ancestor BufferNode which has ElementCollector with PRI_BEFPREMODIFY
 *  priority.
 *
 *   SYNOPSIS
 *  bExist = isECOfBeforeModifyInAncestorIncluded(nIgnoredSecurityId);
 *
 *   FUNCTION
 *  checks each ancestor BufferNode through the parent link, if there is
 *  an ElementCollector with PRI_BEFPREMODIFY priority and its
 *  signatureId is not ignored, then return true, otherwise, false
 *  returned.
 *
 *   INPUTS
 *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
 *                          to UNDEFINEDSECURITYID, then no security Id
 *                          will be ignored.
 *
 *   RESULT
 *  bExist - true if a match found, false otherwise.
 ******************************************************************************/
{
    bool rc = false;
 
    BufferNode* pParentNode = m_pParent;
    while (pParentNode != nullptr)
    {
        if (pParentNode->isECOfBeforeModifyIncluded(nIgnoredSecurityId))
        {
            rc = true;
            break;
        }
 
        pParentNode = const_cast<BufferNode*>(pParentNode->getParent());
    }
 
    return rc;
}
 
bool BufferNode::isBlockerInSubTreeIncluded(sal_Int32 nIgnoredSecurityId) const
/****** BufferNode/isBlockerInSubTreeIncluded ********************************
 *
 *   NAME
 *  isBlockerInSubTreeIncluded -- checks whether there is some BufferNode
 *  which has blocker on it
 *
 *   SYNOPSIS
 *  bExist = isBlockerInSubTreeIncluded(nIgnoredSecurityId);
 *
 *   FUNCTION
 *  checks each BufferNode in the branch of this BufferNode, if one has
 *  a blocker on it, and the blocker's securityId is not ignored, then
 *  returns true; otherwise, false returns.
 *
 *   INPUTS
 *  nIgnoredSecurityId -    the security Id to be ignored. If it equals
 *                          to UNDEFINEDSECURITYID, then no security Id
 *                          will be ignored.
 *
 *   RESULT
 *  bExist - true if a match found, false otherwise.
 ******************************************************************************/
{
    return std::any_of(m_vChildren.begin(), m_vChildren.end(),
        [nIgnoredSecurityId](const std::unique_ptr<BufferNode>& pBufferNode) {
            ElementMark* pBlocker = pBufferNode->getBlocker();
            return (pBlocker != nullptr &&
                (nIgnoredSecurityId == css::xml::crypto::sax::ConstOfSecurityId::UNDEFINEDSECURITYID ||
                 pBlocker->getSecurityId() != nIgnoredSecurityId )) ||
                pBufferNode->isBlockerInSubTreeIncluded(nIgnoredSecurityId);
    });
}
 
const BufferNode* BufferNode::getNextChild(const BufferNode* pChild) const
/****** BufferNode/getNextChild **********************************************
 *
 *   NAME
 *  getNextChild -- get the next child BufferNode.
 *
 *   SYNOPSIS
 *  nextChild = getNextChild();
 *
 *   FUNCTION
 *  see NAME
 *
 *   INPUTS
 *  pChild - the child BufferNode whose next node is retrieved.
 *
 *   RESULT
 *  nextChild - the next child BufferNode after the pChild, or NULL if
 *  there is none.
 ******************************************************************************/
{
    BufferNode* rc = nullptr;
    bool bChildFound = false;
 
    for( std::unique_ptr<BufferNode> const & i : m_vChildren )
    {
        if (bChildFound)
        {
            rc = i.get();
            break;
        }
 
        if( i.get() == pChild )
        {
            bChildFound = true;
        }
    }
 
    return rc;
}
 
/* vim:set shiftwidth=4 softtabstop=4 expandtab: */