#ifndef StructureSet_h
#define StructureSet_h
#include "ArrayProfile.h"
#include "SpeculatedType.h"
#include "Structure.h"
#include "DumpContext.h"
#include <wtf/CommaPrinter.h>
#include <wtf/Vector.h>
namespace JSC {
namespace DFG {
class StructureAbstractValue;
}
class StructureSet {
public:
StructureSet() { }
StructureSet(Structure* structure)
{
ASSERT(structure);
m_structures.append(structure);
}
void clear()
{
m_structures.clear();
}
void add(Structure* structure)
{
ASSERT(structure);
ASSERT(!contains(structure));
m_structures.append(structure);
}
bool addAll(const StructureSet& other)
{
bool changed = false;
for (size_t i = 0; i < other.size(); ++i) {
if (contains(other[i]))
continue;
add(other[i]);
changed = true;
}
return changed;
}
void remove(Structure* structure)
{
for (size_t i = 0; i < m_structures.size(); ++i) {
if (m_structures[i] != structure)
continue;
m_structures[i] = m_structures.last();
m_structures.removeLast();
return;
}
}
bool contains(Structure* structure) const
{
for (size_t i = 0; i < m_structures.size(); ++i) {
if (m_structures[i] == structure)
return true;
}
return false;
}
bool containsOnly(Structure* structure) const
{
if (size() != 1)
return false;
return singletonStructure() == structure;
}
bool isSubsetOf(const StructureSet& other) const
{
for (size_t i = 0; i < m_structures.size(); ++i) {
if (!other.contains(m_structures[i]))
return false;
}
return true;
}
bool isSupersetOf(const StructureSet& other) const
{
return other.isSubsetOf(*this);
}
bool overlaps(const StructureSet& other) const
{
for (size_t i = 0; i < m_structures.size(); ++i) {
if (other.contains(m_structures[i]))
return true;
}
return false;
}
size_t size() const { return m_structures.size(); }
Structure* singletonStructure() const
{
ASSERT(m_structures.size() == 1);
return m_structures[0];
}
Structure* at(size_t i) const { return m_structures.at(i); }
Structure* operator[](size_t i) const { return at(i); }
Structure* last() const { return m_structures.last(); }
SpeculatedType speculationFromStructures() const
{
SpeculatedType result = SpecNone;
for (size_t i = 0; i < m_structures.size(); ++i)
mergeSpeculation(result, speculationFromStructure(m_structures[i]));
return result;
}
ArrayModes arrayModesFromStructures() const
{
ArrayModes result = 0;
for (size_t i = 0; i < m_structures.size(); ++i)
mergeArrayModes(result, asArrayModes(m_structures[i]->indexingType()));
return result;
}
bool operator==(const StructureSet& other) const
{
if (m_structures.size() != other.m_structures.size())
return false;
for (size_t i = 0; i < m_structures.size(); ++i) {
if (!other.contains(m_structures[i]))
return false;
}
return true;
}
void dumpInContext(PrintStream& out, DumpContext* context) const
{
CommaPrinter comma;
out.print("[");
for (size_t i = 0; i < m_structures.size(); ++i)
out.print(comma, inContext(*m_structures[i], context));
out.print("]");
}
void dump(PrintStream& out) const
{
dumpInContext(out, 0);
}
private:
friend class DFG::StructureAbstractValue;
Vector<Structure*, 2> m_structures;
};
}
#endif // StructureSet_h