TypedElementDescendantIterator.h [plain text]
#pragma once
#include "ElementIterator.h"
namespace WebCore {
template<typename ElementType> class DoubleTypedElementDescendantIterator;
template <typename ElementType>
class TypedElementDescendantIterator : public ElementIterator<ElementType> {
public:
TypedElementDescendantIterator(const ContainerNode& root);
TypedElementDescendantIterator(const ContainerNode& root, ElementType* current);
TypedElementDescendantIterator& operator++();
};
template <typename ElementType>
class TypedElementDescendantConstIterator : public ElementConstIterator<ElementType> {
public:
TypedElementDescendantConstIterator(const ContainerNode& root);
TypedElementDescendantConstIterator(const ContainerNode& root, const ElementType* current);
TypedElementDescendantConstIterator& operator++();
};
template <typename ElementType>
class TypedElementDescendantIteratorAdapter {
public:
TypedElementDescendantIteratorAdapter(ContainerNode& root);
TypedElementDescendantIterator<ElementType> begin();
TypedElementDescendantIterator<ElementType> end();
TypedElementDescendantIterator<ElementType> beginAt(ElementType&);
TypedElementDescendantIterator<ElementType> from(Element&);
ElementType* first();
ElementType* last();
private:
ContainerNode& m_root;
};
template <typename ElementType>
class TypedElementDescendantConstIteratorAdapter {
public:
TypedElementDescendantConstIteratorAdapter(const ContainerNode& root);
TypedElementDescendantConstIterator<ElementType> begin() const;
TypedElementDescendantConstIterator<ElementType> end() const;
TypedElementDescendantConstIterator<ElementType> beginAt(const ElementType&) const;
TypedElementDescendantConstIterator<ElementType> from(const Element&) const;
const ElementType* first() const;
const ElementType* last() const;
private:
const ContainerNode& m_root;
};
template<typename ElementType> class DoubleTypedElementDescendantIteratorAdapter {
public:
typedef TypedElementDescendantIteratorAdapter<ElementType> SingleAdapter;
typedef DoubleTypedElementDescendantIterator<ElementType> Iterator;
DoubleTypedElementDescendantIteratorAdapter(SingleAdapter&&, SingleAdapter&&);
Iterator begin();
Iterator end();
private:
std::pair<SingleAdapter, SingleAdapter> m_pair;
};
template<typename ElementType> class DoubleTypedElementDescendantIterator {
public:
typedef TypedElementDescendantIterator<ElementType> SingleIterator;
typedef std::pair<ElementType&, ElementType&> ReferenceProxy;
DoubleTypedElementDescendantIterator(SingleIterator&&, SingleIterator&&);
ReferenceProxy operator*() const;
bool operator==(const DoubleTypedElementDescendantIterator&) const;
bool operator!=(const DoubleTypedElementDescendantIterator&) const;
DoubleTypedElementDescendantIterator& operator++();
private:
std::pair<SingleIterator, SingleIterator> m_pair;
};
template <typename ElementType> TypedElementDescendantIteratorAdapter<ElementType> descendantsOfType(ContainerNode&);
template <typename ElementType> TypedElementDescendantConstIteratorAdapter<ElementType> descendantsOfType(const ContainerNode&);
template<typename ElementType> DoubleTypedElementDescendantIteratorAdapter<ElementType> descendantsOfType(ContainerNode& firstRoot, ContainerNode& secondRoot);
template <typename ElementType>
inline TypedElementDescendantIterator<ElementType>::TypedElementDescendantIterator(const ContainerNode& root)
: ElementIterator<ElementType>(&root)
{
}
template <typename ElementType>
inline TypedElementDescendantIterator<ElementType>::TypedElementDescendantIterator(const ContainerNode& root, ElementType* current)
: ElementIterator<ElementType>(&root, current)
{
}
template <typename ElementType>
inline TypedElementDescendantIterator<ElementType>& TypedElementDescendantIterator<ElementType>::operator++()
{
return static_cast<TypedElementDescendantIterator<ElementType>&>(ElementIterator<ElementType>::traverseNext());
}
template <typename ElementType>
inline TypedElementDescendantConstIterator<ElementType>::TypedElementDescendantConstIterator(const ContainerNode& root)
: ElementConstIterator<ElementType>(&root)
{
}
template <typename ElementType>
inline TypedElementDescendantConstIterator<ElementType>::TypedElementDescendantConstIterator(const ContainerNode& root, const ElementType* current)
: ElementConstIterator<ElementType>(&root, current)
{
}
template <typename ElementType>
inline TypedElementDescendantConstIterator<ElementType>& TypedElementDescendantConstIterator<ElementType>::operator++()
{
return static_cast<TypedElementDescendantConstIterator<ElementType>&>(ElementConstIterator<ElementType>::traverseNext());
}
template <typename ElementType>
inline TypedElementDescendantIteratorAdapter<ElementType>::TypedElementDescendantIteratorAdapter(ContainerNode& root)
: m_root(root)
{
}
template <typename ElementType>
inline TypedElementDescendantIterator<ElementType> TypedElementDescendantIteratorAdapter<ElementType>::begin()
{
return TypedElementDescendantIterator<ElementType>(m_root, Traversal<ElementType>::firstWithin(m_root));
}
template <typename ElementType>
inline TypedElementDescendantIterator<ElementType> TypedElementDescendantIteratorAdapter<ElementType>::end()
{
return TypedElementDescendantIterator<ElementType>(m_root);
}
template <typename ElementType>
inline TypedElementDescendantIterator<ElementType> TypedElementDescendantIteratorAdapter<ElementType>::beginAt(ElementType& descendant)
{
ASSERT(descendant.isDescendantOf(m_root));
return TypedElementDescendantIterator<ElementType>(m_root, &descendant);
}
template <typename ElementType>
inline TypedElementDescendantIterator<ElementType> TypedElementDescendantIteratorAdapter<ElementType>::from(Element& descendant)
{
ASSERT(descendant.isDescendantOf(m_root));
if (is<ElementType>(descendant))
return TypedElementDescendantIterator<ElementType>(m_root, downcast<ElementType>(&descendant));
ElementType* next = Traversal<ElementType>::next(descendant, &m_root);
return TypedElementDescendantIterator<ElementType>(m_root, next);
}
template <typename ElementType>
inline ElementType* TypedElementDescendantIteratorAdapter<ElementType>::first()
{
return Traversal<ElementType>::firstWithin(m_root);
}
template <typename ElementType>
inline ElementType* TypedElementDescendantIteratorAdapter<ElementType>::last()
{
return Traversal<ElementType>::lastWithin(m_root);
}
template <typename ElementType>
inline TypedElementDescendantConstIteratorAdapter<ElementType>::TypedElementDescendantConstIteratorAdapter(const ContainerNode& root)
: m_root(root)
{
}
template <typename ElementType>
inline TypedElementDescendantConstIterator<ElementType> TypedElementDescendantConstIteratorAdapter<ElementType>::begin() const
{
return TypedElementDescendantConstIterator<ElementType>(m_root, Traversal<ElementType>::firstWithin(m_root));
}
template <typename ElementType>
inline TypedElementDescendantConstIterator<ElementType> TypedElementDescendantConstIteratorAdapter<ElementType>::end() const
{
return TypedElementDescendantConstIterator<ElementType>(m_root);
}
template <typename ElementType>
inline TypedElementDescendantConstIterator<ElementType> TypedElementDescendantConstIteratorAdapter<ElementType>::beginAt(const ElementType& descendant) const
{
ASSERT(descendant.isDescendantOf(m_root));
return TypedElementDescendantConstIterator<ElementType>(m_root, &descendant);
}
template <typename ElementType>
inline TypedElementDescendantConstIterator<ElementType> TypedElementDescendantConstIteratorAdapter<ElementType>::from(const Element& descendant) const
{
ASSERT(descendant.isDescendantOf(m_root));
if (is<ElementType>(descendant))
return TypedElementDescendantConstIterator<ElementType>(m_root, downcast<ElementType>(&descendant));
const ElementType* next = Traversal<ElementType>::next(descendant, &m_root);
return TypedElementDescendantConstIterator<ElementType>(m_root, next);
}
template <typename ElementType>
inline const ElementType* TypedElementDescendantConstIteratorAdapter<ElementType>::first() const
{
return Traversal<ElementType>::firstWithin(m_root);
}
template <typename ElementType>
inline const ElementType* TypedElementDescendantConstIteratorAdapter<ElementType>::last() const
{
return Traversal<ElementType>::lastWithin(m_root);
}
template<typename ElementType> inline DoubleTypedElementDescendantIteratorAdapter<ElementType>::DoubleTypedElementDescendantIteratorAdapter(SingleAdapter&& first, SingleAdapter&& second)
: m_pair(WTFMove(first), WTFMove(second))
{
}
template<typename ElementType> inline auto DoubleTypedElementDescendantIteratorAdapter<ElementType>::begin() -> Iterator
{
return Iterator(m_pair.first.begin(), m_pair.second.begin());
}
template<typename ElementType> inline auto DoubleTypedElementDescendantIteratorAdapter<ElementType>::end() -> Iterator
{
return Iterator(m_pair.first.end(), m_pair.second.end());
}
template<typename ElementType> inline DoubleTypedElementDescendantIterator<ElementType>::DoubleTypedElementDescendantIterator(SingleIterator&& first, SingleIterator&& second)
: m_pair(WTFMove(first), WTFMove(second))
{
}
template<typename ElementType> inline auto DoubleTypedElementDescendantIterator<ElementType>::operator*() const -> ReferenceProxy
{
return { *m_pair.first, *m_pair.second };
}
template<typename ElementType> inline bool DoubleTypedElementDescendantIterator<ElementType>::operator==(const DoubleTypedElementDescendantIterator& other) const
{
ASSERT((m_pair.first == other.m_pair.first) == (m_pair.second == other.m_pair.second));
return m_pair.first == other.m_pair.first || m_pair.second == other.m_pair.second;
}
template<typename ElementType> inline bool DoubleTypedElementDescendantIterator<ElementType>::operator!=(const DoubleTypedElementDescendantIterator& other) const
{
return !(*this == other);
}
template<typename ElementType> inline DoubleTypedElementDescendantIterator<ElementType>& DoubleTypedElementDescendantIterator<ElementType>::operator++()
{
++m_pair.first;
++m_pair.second;
return *this;
}
template <typename ElementType>
inline TypedElementDescendantIteratorAdapter<ElementType> descendantsOfType(ContainerNode& root)
{
return TypedElementDescendantIteratorAdapter<ElementType>(root);
}
template <typename ElementType>
inline TypedElementDescendantConstIteratorAdapter<ElementType> descendantsOfType(const ContainerNode& root)
{
return TypedElementDescendantConstIteratorAdapter<ElementType>(root);
}
template<typename ElementType> inline DoubleTypedElementDescendantIteratorAdapter<ElementType> descendantsOfType(ContainerNode& firstRoot, ContainerNode& secondRoot)
{
return { descendantsOfType<ElementType>(firstRoot), descendantsOfType<ElementType>(secondRoot) };
}
}