#pragma once
#include <wtf/BitVector.h>
#include <wtf/CommaPrinter.h>
namespace WTF {
template<typename T>
class IndexSet {
public:
IndexSet()
{
}
bool add(T* value)
{
return !m_set.set(value->index());
}
template<typename Iterable>
bool addAll(const Iterable& iterable)
{
bool result = false;
for (T* value : iterable)
result |= add(value);
return result;
}
bool remove(T* value)
{
return m_set.clear(value->index());
}
bool contains(T* value) const
{
if (!value)
return false;
return m_set.get(value->index());
}
size_t size() const
{
return m_set.bitCount();
}
bool isEmpty() const
{
return !size();
}
template<typename CollectionType>
class Iterable {
public:
Iterable(const CollectionType& collection, const BitVector& set)
: m_collection(collection)
, m_set(set)
{
}
class iterator {
public:
iterator()
: m_collection(nullptr)
{
}
iterator(const CollectionType& collection, BitVector::iterator iter)
: m_collection(&collection)
, m_iter(iter)
{
}
T* operator*()
{
return m_collection->at(*m_iter);
}
iterator& operator++()
{
++m_iter;
return *this;
}
bool operator==(const iterator& other) const
{
return m_iter == other.m_iter;
}
bool operator!=(const iterator& other) const
{
return !(*this == other);
}
private:
const CollectionType* m_collection;
BitVector::iterator m_iter;
};
iterator begin() const { return iterator(m_collection, m_set.begin()); }
iterator end() const { return iterator(m_collection, m_set.end()); }
private:
const CollectionType& m_collection;
const BitVector& m_set;
};
template<typename CollectionType>
Iterable<CollectionType> values(const CollectionType& collection) const
{
return Iterable<CollectionType>(collection, indices());
}
const BitVector& indices() const { return m_set; }
void dump(PrintStream& out) const
{
CommaPrinter comma;
for (size_t index : indices())
out.print(comma, T::dumpPrefix, index);
}
private:
BitVector m_set;
};
}
using WTF::IndexSet;