summaryrefslogtreecommitdiffstats
path: root/src/3rdparty/phonon/mmf/objecttree.h
blob: 96adb6fb3adfbbcc6f1102bdef917e1539fb7d0c (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
/*  This file is part of the KDE project.

Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

This library is free software: you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
the Free Software Foundation, either version 2.1 or 3 of the License.

This library is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public License
along with this library.  If not, see <http://www.gnu.org/licenses/>.

*/

#ifndef OBJECTTREE_H
#define OBJECTTREE_H

#include <QObject>
#include <QStack>

QT_BEGIN_NAMESPACE

namespace ObjectTree
{

/**
 * Depth-first iterator for QObject tree
 */
class DepthFirstConstIterator
{
public:
    DepthFirstConstIterator();
    DepthFirstConstIterator(const QObject& root);

    DepthFirstConstIterator& operator++();

    inline bool operator==(const DepthFirstConstIterator& other) const
    { return other.m_pointee == m_pointee; }

    inline bool operator!=(const DepthFirstConstIterator& other) const
    { return other.m_pointee != m_pointee; }

    inline const QObject* operator->() const { return m_pointee; }
    inline const QObject& operator*() const { return *m_pointee; }

private:
    void backtrack();

private:
    const QObject* m_pointee;
    QStack<int> m_history;
};

/**
 * Ancestor iterator for QObject tree
 */
class AncestorConstIterator
{
public:
    AncestorConstIterator();
    AncestorConstIterator(const QObject& root);

    inline AncestorConstIterator& operator++()
    { m_ancestors.pop(); return *this; }

    inline bool operator==(const AncestorConstIterator& other) const
    { return other.m_ancestors == m_ancestors; }

    inline bool operator!=(const AncestorConstIterator& other) const
    { return other.m_ancestors != m_ancestors; }

    inline const QObject* operator->() const { return m_ancestors.top(); }
    inline const QObject& operator*() const { return *m_ancestors.top(); }

private:
    QStack<const QObject*> m_ancestors;

};

/**
 * Generic algorithm for visiting nodes in an object tree.  Nodes in the
 * tree are visited in a const context, therefore they are not modified
 * by this algorithm.
 *
 * Visitor must provide functions with the following signatures:
 *
 *      Called before visit begins
 *          void visitPrepare()
 *
 *      Called on each node visited
 *          void visitNode(const QObject& object)
 *
 *      Called when visit is complete
 *          void visitComplete()
 */
template <class Iterator, class Visitor>
void visit(Iterator begin, Iterator end, Visitor& visitor)
{
    visitor.visitPrepare();

    for ( ; begin != end; ++begin)
        visitor.visitNode(*begin);

    visitor.visitComplete();
}

} // namespace ObjectTree

QT_END_NAMESPACE

#endif // OBJECTTREE_H