[WTF] Import std::optional reference implementation as WTF::Optional
[WebKit-https.git] / Source / JavaScriptCore / runtime / PropertyName.h
index 9e99f53..d1d4d19 100644 (file)
  * THE POSSIBILITY OF SUCH DAMAGE.
  */
 
-#ifndef PropertyName_h
-#define PropertyName_h
+#pragma once
 
 #include "Identifier.h"
 #include "PrivateName.h"
+#include <wtf/Optional.h>
 
 namespace JSC {
 
-template <typename CharType>
-ALWAYS_INLINE uint32_t toUInt32FromCharacters(const CharType* characters, unsigned length)
-{
-    // An empty string is not a number.
-    if (!length)
-        return UINT_MAX;
-
-    // Get the first character, turning it into a digit.
-    uint32_t value = characters[0] - '0';
-    if (value > 9)
-        return UINT_MAX;
-    
-    // Check for leading zeros. If the first characher is 0, then the
-    // length of the string must be one - e.g. "042" is not equal to "42".
-    if (!value && length > 1)
-        return UINT_MAX;
-    
-    while (--length) {
-        // Multiply value by 10, checking for overflow out of 32 bits.
-        if (value > 0xFFFFFFFFU / 10)
-            return UINT_MAX;
-        value *= 10;
-        
-        // Get the next character, turning it into a digit.
-        uint32_t newValue = *(++characters) - '0';
-        if (newValue > 9)
-            return UINT_MAX;
-        
-        // Add in the old value, checking for overflow out of 32 bits.
-        newValue += value;
-        if (newValue < value)
-            return UINT_MAX;
-        value = newValue;
-    }
-    
-    return value;
-}
-
-ALWAYS_INLINE uint32_t toUInt32FromStringImpl(StringImpl* impl)
-{
-    if (impl->is8Bit())
-        return toUInt32FromCharacters(impl->characters8(), impl->length());
-    return toUInt32FromCharacters(impl->characters16(), impl->length());
-}
-
 class PropertyName {
 public:
+    PropertyName(UniquedStringImpl* propertyName)
+        : m_impl(propertyName)
+    {
+    }
+
     PropertyName(const Identifier& propertyName)
-        : m_impl(static_cast<AtomicStringImpl*>(propertyName.impl()))
+        : PropertyName(propertyName.impl())
     {
-        ASSERT(!m_impl || m_impl->isAtomic());
     }
 
     PropertyName(const PrivateName& propertyName)
-        : m_impl(static_cast<AtomicStringImpl*>(propertyName.uid()))
+        : m_impl(&propertyName.uid())
     {
         ASSERT(m_impl);
-        ASSERT(m_impl->isEmptyUnique());
-        ASSERT(m_impl->isAtomic());
+        ASSERT(m_impl->isSymbol());
     }
 
-    AtomicStringImpl* uid() const
+    bool isNull() const { return !m_impl; }
+
+    bool isSymbol()
     {
-        return m_impl;
+        return m_impl && m_impl->isSymbol();
     }
 
-    AtomicStringImpl* publicName() const
+    UniquedStringImpl* uid() const
     {
-        return m_impl->isEmptyUnique() ? nullptr : m_impl;
+        return m_impl;
     }
 
-    static const uint32_t NotAnIndex = UINT_MAX;
-
-    uint32_t asIndex()
+    AtomicStringImpl* publicName() const
     {
-        return m_impl ? toUInt32FromStringImpl(m_impl) : NotAnIndex;
+        return (!m_impl || m_impl->isSymbol()) ? nullptr : static_cast<AtomicStringImpl*>(m_impl);
     }
-    
+
     void dump(PrintStream& out) const
     {
         if (m_impl)
@@ -118,7 +76,7 @@ public:
     }
 
 private:
-    AtomicStringImpl* m_impl;
+    UniquedStringImpl* m_impl;
 };
 
 inline bool operator==(PropertyName a, const Identifier& b)
@@ -136,6 +94,11 @@ 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();
@@ -151,6 +114,14 @@ inline bool operator!=(PropertyName a, PropertyName b)
     return a.uid() != b.uid();
 }
 
+ALWAYS_INLINE std::optional<uint32_t> parseIndex(PropertyName propertyName)
+{
+    auto uid = propertyName.uid();
+    if (!uid)
+        return std::nullopt;
+    if (uid->isSymbol())
+        return std::nullopt;
+    return parseIndex(*uid);
 }
 
-#endif
+} // namespace JSC