#ifndef PropertyName_h
#define PropertyName_h
#include "Identifier.h"
#include "PrivateName.h"
#include <wtf/Optional.h>
namespace JSC {
class PropertyName {
public:
PropertyName(UniquedStringImpl* propertyName)
: m_impl(propertyName)
{
}
PropertyName(const Identifier& propertyName)
: PropertyName(propertyName.impl())
{
}
PropertyName(const PrivateName& propertyName)
: m_impl(propertyName.uid())
{
ASSERT(m_impl);
ASSERT(m_impl->isSymbol());
}
bool isNull() const { return !m_impl; }
bool isSymbol()
{
return m_impl && m_impl->isSymbol();
}
UniquedStringImpl* uid() const
{
return m_impl;
}
AtomicStringImpl* publicName() const
{
return (!m_impl || m_impl->isSymbol()) ? nullptr : static_cast<AtomicStringImpl*>(m_impl);
}
void dump(PrintStream& out) const
{
if (m_impl)
out.print(m_impl);
else
out.print("<null property name>");
}
private:
UniquedStringImpl* m_impl;
};
inline bool operator==(PropertyName a, const Identifier& b)
{
return a.uid() == b.impl();
}
inline bool operator==(const Identifier& a, PropertyName b)
{
return a.impl() == b.uid();
}
inline bool operator==(PropertyName a, PropertyName b)
{
return a.uid() == b.uid();
}
inline bool operator==(PropertyName a, const char* b)
{
return equal(a.uid(), b);
}
inline bool operator!=(PropertyName a, const Identifier& b)
{
return a.uid() != b.impl();
}
inline bool operator!=(const Identifier& a, PropertyName b)
{
return a.impl() != b.uid();
}
inline bool operator!=(PropertyName a, PropertyName b)
{
return a.uid() != b.uid();
}
ALWAYS_INLINE Optional<uint32_t> parseIndex(PropertyName propertyName)
{
auto uid = propertyName.uid();
if (!uid)
return Nullopt;
if (uid->isSymbol())
return Nullopt;
return parseIndex(*uid);
}
}
#endif