blob: 7ff7c68ca6ebadd04a427a8f1a7375e36e8894f8 (
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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
|
// Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "cc/layers/layer_list_iterator.h"
#include "cc/layers/layer.h"
#include "cc/layers/layer_impl.h"
namespace cc {
static Layer* Parent(Layer* layer) {
return layer->parent();
}
static LayerImpl* Parent(LayerImpl* layer) {
return layer->test_properties()->parent;
}
template <typename LayerType>
LayerListIterator<LayerType>::LayerListIterator(LayerType* root_layer)
: current_layer_(root_layer) {
DCHECK(!root_layer || !Parent(root_layer));
list_indices_.push_back(0);
}
static LayerImplList& Children(LayerImpl* layer) {
return layer->test_properties()->children;
}
static const LayerList& Children(Layer* layer) {
return layer->children();
}
static LayerImpl* ChildAt(LayerImpl* layer, int index) {
return layer->test_properties()->children[index];
}
static Layer* ChildAt(Layer* layer, int index) {
return layer->children()[index].get();
}
template <typename LayerType>
LayerListIterator<LayerType>::LayerListIterator(
const LayerListIterator<LayerType>& other) = default;
template <typename LayerType>
LayerListIterator<LayerType>::~LayerListIterator() = default;
template <typename LayerType>
LayerListIterator<LayerType>& LayerListIterator<LayerType>::operator++() {
// case 0: done
if (!current_layer_)
return *this;
// case 1: descend.
if (!Children(current_layer_).empty()) {
current_layer_ = ChildAt(current_layer_, 0);
list_indices_.push_back(0);
return *this;
}
for (LayerType* parent = Parent(current_layer_); parent;
parent = Parent(parent)) {
// We now try and advance in some list of siblings.
// case 2: Advance to a sibling.
if (list_indices_.back() + 1 < Children(parent).size()) {
++list_indices_.back();
current_layer_ = ChildAt(parent, list_indices_.back());
return *this;
}
// We need to ascend. We will pop an index off the stack.
list_indices_.pop_back();
}
current_layer_ = nullptr;
return *this;
}
template <typename LayerType>
LayerListReverseIterator<LayerType>::LayerListReverseIterator(
LayerType* root_layer)
: LayerListIterator<LayerType>(root_layer) {
DescendToRightmostInSubtree();
}
template <typename LayerType>
LayerListReverseIterator<LayerType>::~LayerListReverseIterator() = default;
// We will only support prefix increment.
template <typename LayerType>
LayerListIterator<LayerType>& LayerListReverseIterator<LayerType>::
operator++() {
// case 0: done
if (!current_layer())
return *this;
// case 1: we're the leftmost sibling.
if (!list_indices().back()) {
list_indices().pop_back();
this->current_layer_ = Parent(current_layer());
return *this;
}
// case 2: we're not the leftmost sibling. In this case, we want to move one
// sibling over, and then descend to the rightmost descendant in that subtree.
CHECK(Parent(current_layer()));
--list_indices().back();
this->current_layer_ =
ChildAt(Parent(current_layer()), list_indices().back());
DescendToRightmostInSubtree();
return *this;
}
template <typename LayerType>
void LayerListReverseIterator<LayerType>::DescendToRightmostInSubtree() {
if (!current_layer())
return;
if (Children(current_layer()).empty())
return;
size_t last_index = Children(current_layer()).size() - 1;
this->current_layer_ = ChildAt(current_layer(), last_index);
list_indices().push_back(last_index);
DescendToRightmostInSubtree();
}
template class LayerListIterator<Layer>;
template class LayerListIterator<LayerImpl>;
template class LayerListReverseIterator<Layer>;
template class LayerListReverseIterator<LayerImpl>;
} // namespace cc
|
