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
|
/*
* Copyright (C) 2008, 2014 Apple Inc. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#pragma once
#include <WebCore/CSSSelector.h>
#include <iterator>
#include <memory>
#include <wtf/TZoneMalloc.h>
#include <wtf/UniqueArray.h>
namespace WebCore {
class MutableCSSSelector;
using MutableCSSSelectorList = Vector<std::unique_ptr<MutableCSSSelector>>;
class CSSSelectorList {
WTF_MAKE_TZONE_ALLOCATED(CSSSelectorList);
public:
CSSSelectorList() = default;
CSSSelectorList(const CSSSelectorList&);
CSSSelectorList(CSSSelectorList&&) = default;
explicit CSSSelectorList(MutableCSSSelectorList&&);
explicit CSSSelectorList(UniqueArray<CSSSelector>&& array)
: m_selectorArray(WTFMove(array)) { }
static CSSSelectorList makeCopyingSimpleSelector(const CSSSelector&);
static CSSSelectorList makeCopyingComplexSelector(const CSSSelector&);
static CSSSelectorList makeJoining(const CSSSelectorList&, const CSSSelectorList&);
static CSSSelectorList makeJoining(const Vector<const CSSSelectorList*>&);
bool isEmpty() const { return !m_selectorArray; }
const CSSSelector* first() const { return m_selectorArray.get(); }
const CSSSelector* selectorAt(size_t index) const
{
WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN
return &m_selectorArray[index];
WTF_ALLOW_UNSAFE_BUFFER_USAGE_END
}
size_t indexOfNextSelectorAfter(size_t index) const
{
const_iterator current = selectorAt(index);
++current;
if (current == end())
return notFound;
return &*current - m_selectorArray.get();
}
struct const_iterator {
friend class CSSSelectorList;
using value_type = CSSSelector;
using difference_type = std::ptrdiff_t;
using pointer = const CSSSelector*;
using reference = const CSSSelector&;
using iterator_category = std::forward_iterator_tag;
reference operator*() const { return *m_ptr; }
pointer operator->() const { return m_ptr; }
bool operator==(const const_iterator&) const = default;
const_iterator() = default;
const_iterator(pointer ptr)
: m_ptr(ptr)
{ }
WTF_ALLOW_UNSAFE_BUFFER_USAGE_BEGIN
const_iterator& operator++()
{
// Skip subparts of compound selectors.
while (!m_ptr->isFirstInComplexSelector())
++m_ptr;
m_ptr = m_ptr->isLastInSelectorList() ? nullptr : m_ptr + 1;
return *this;
}
WTF_ALLOW_UNSAFE_BUFFER_USAGE_END
const_iterator operator++(int)
{
const_iterator temp = *this;
++*this;
return temp;
}
private:
pointer m_ptr = nullptr;
};
const_iterator begin() const LIFETIME_BOUND { return { first() }; };
const_iterator end() const LIFETIME_BOUND { return { }; }
bool hasExplicitNestingParent() const;
bool hasOnlyNestingSelector() const;
String selectorsText() const;
void buildSelectorsText(StringBuilder&) const;
unsigned componentCount() const;
unsigned listSize() const;
CSSSelectorList& operator=(CSSSelectorList&&) = default;
bool operator==(const CSSSelectorList&) const;
private:
// End of a multipart selector is indicated by m_isLastInComplexSelector bit in the last item.
// End of the array is indicated by m_isLastInSelectorList bit in the last item.
UniqueArray<CSSSelector> m_selectorArray;
};
} // namespace WebCore
|
