Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-11-03 23:00:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibJS/Runtime/Map.h

117 lines
2.9 KiB
C
Raw Normal View History

LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
/*
* Copyright (c) 2021, Idan Horowitz <idan.horowitz@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
#include <AK/Concepts.h>
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
#include <AK/HashMap.h>
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
#include <AK/RedBlackTree.h>
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
#include <LibJS/Runtime/GlobalObject.h>
#include <LibJS/Runtime/Object.h>
#include <LibJS/Runtime/Value.h>
LibJS: Avoid unnecessary ToObject conversion when resolving references When performing GetValue on a primitive type we do not need to perform the ToObject conversion as it will resolve to a property on the prototype object. To avoid this we skip the initial ToObject conversion on the base value as it only serves to get the primitive's boxed prototype. We further specialize on PrimitiveString in order to get efficient behaviour behaviour for the direct properties. Depending on the tests anywhere from 20 to 60%, with significant loop overhead.
2022-02-12 00:48:23 -08:00
#include <LibJS/Runtime/ValueTraits.h>
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
namespace JS {
class Map : public Object {
JS_OBJECT(Map, Object);
public:
static Map* create(GlobalObject&);
explicit Map(Object& prototype);
Libraries: Use default constructors/destructors in LibJS https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-14 10:25:06 -06:00
virtual ~Map() override = default;
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
void map_clear();
bool map_remove(Value const&);
Optional<Value> map_get(Value const&) const;
bool map_has(Value const&) const;
void map_set(Value const&, Value);
size_t map_size() const;
struct EndIterator {
};
template<bool IsConst>
struct IteratorImpl {
bool is_end() const
{
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
return m_map.m_keys.begin_from(m_index).is_end()
&& m_map.m_keys.find_smallest_not_below_iterator(m_index).is_end();
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
}
IteratorImpl& operator++()
{
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
++m_index;
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
return *this;
}
decltype(auto) operator*()
{
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
ensure_next_element();
return *m_map.m_entries.find(*m_map.m_keys.begin_from(m_index));
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
}
decltype(auto) operator*() const
{
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
ensure_next_element();
return *m_map.m_entries.find(*m_map.m_keys.begin_from(m_index));
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
}
bool operator==(IteratorImpl const& other) const { return m_index == other.m_index && &m_map == &other.m_map; }
bool operator==(EndIterator const&) const { return is_end(); }
private:
friend class Map;
IteratorImpl(Map const& map) requires(IsConst)
: m_map(map)
{
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
ensure_index();
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
}
IteratorImpl(Map& map) requires(!IsConst)
: m_map(map)
{
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
ensure_index();
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
}
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
void ensure_index() const
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
{
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
if (m_map.m_keys.is_empty())
m_index = m_map.m_next_insertion_id;
else
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
m_index = m_map.m_keys.begin().key();
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
}
void ensure_next_element() const
{
if (auto it = m_map.m_keys.find_smallest_not_below_iterator(m_index); it.is_end())
m_index = m_map.m_next_insertion_id;
else
m_index = it.key();
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
}
Conditional<IsConst, Map const&, Map&> m_map;
LibJS: Fix Map Iterators when elements are deleted during iteration Before this would assume that the element found in operator++ was still valid when dereferencing it in operator*. Since any code can have been run since that increment this is not always valid. To further simplify the logic of the iterator we no longer store the index in an optional.
2022-02-10 11:13:53 +01:00
mutable size_t m_index { 0 };
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
};
using Iterator = IteratorImpl<false>;
using ConstIterator = IteratorImpl<true>;
ConstIterator begin() const { return { *this }; }
Iterator begin() { return { *this }; }
EndIterator end() const { return {}; }
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
private:
virtual void visit_edges(Visitor& visitor) override;
LibJS: Make Map iterators independent of the underlying hashmap This implements ordered maps as a pair of an RBTree for key order, and an underlying unordered hash map for storage. Fixes (part of) #11004.
2022-02-09 16:34:52 +03:30
size_t m_next_insertion_id { 0 };
RedBlackTree<size_t, Value> m_keys;
HashMap<Value, Value, ValueTraits> m_entries;
LibJS: Add the Map built-in object
2021-06-12 23:54:40 +03:00
};
}
Reference in a new issue Copy permalink