Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-browser-engine

Source of release 0.6.0

0.6.0 / src / web / dom / element_by_id_map.lucb

#==============================================================================================
#
#   element_by_id_map - DOM::ElementByIdMap: the id → elements index of a document or shadow root
#
#   DESCRIPTION:
#       Port of LibWeb/DOM/ElementByIdMap.cpp (lines 1-94) and the inline functions of
#       ElementByIdMap.h. Each id maps to weak references to the elements carrying it and a
#       cached first element in tree order. The map is a value inside its Document or
#       ShadowRoot cell.
#
#==============================================================================================

## `Concepts::HashCompatible<FlyString, StringView>`: looking the FlyString-keyed map up by a
## StringView (`m_map.get(element_id)` with a StringView). A StringView hashes as the FlyString
## with the same bytes, and `FlyString == StringView` compares the bytes.
struct DomFlyStringStringViewTraits: ak.HashCompatibleTraits[ak.FlyString, ak.StringView]:
    var empty_: u8

    func hash_of(key: const ak.StringView*) -> u32: return ak.string_view_hash(key)

    func equals(entry: const ak.FlyString*, key: const ak.StringView*) -> bool: return ak.fly_string_eq_string_view(entry, *key)

## ElementByIdMap::add's `m_map.ensure(element_id, [] { return MapEntry {}; })` initializer.
func dom_element_by_id_map_new_entry(context: void*?) -> DomElementByIdMapMapEntry:
    var entry: DomElementByIdMapMapEntry
    return entry

## Ported from ElementByIdMap.cpp:11 Web::DOM::ElementByIdMap::add.
pub func dom_element_by_id_map_add(this: DomElementByIdMap*, element_id: ak.FlyString, element: DomElement*):
    let initializer = ak.Function0[DomElementByIdMapMapEntry](call = dom_element_by_id_map_new_entry, context = none)
    let entry = ak.hash_map_ensure_t_callback(&this.m_map, element_id, initializer)

    for existing in ak.vector_span(&entry.elements):
        if gc.weak_ptr(&existing) == element:
            return

    ak.vector_append_t(&entry.elements, gc.make_weak[DomElement](element))

    if ak.vector_size(&entry.elements) == 1:
        gc.weak_assign[DomElement](&entry.cached_first_element, element)
    else:
        gc.weak_assign[DomElement](&entry.cached_first_element, none)

## ElementByIdMap::remove's remove_all_matching predicate: `!weak_el || weak_el.ptr() == &element`.
func dom_element_by_id_map_remove_matches(context: void*?, weak_el: const gc.Weak[DomElement]*) -> bool:
    let element = (DomElement*)(context else trap("no element"))
    let pointer = gc.weak_ptr(weak_el) else return true
    return pointer == element

## Ported from ElementByIdMap.cpp:29 Web::DOM::ElementByIdMap::remove.
pub func dom_element_by_id_map_remove(this: DomElementByIdMap*, element_id: ak.FlyString, element: DomElement*):
    let it = ak.hash_map_find_k(&this.m_map, element_id)
    let bucket = it.m_bucket else return
    let entry = &bucket.storage.value

    let predicate = ak.Function1[const gc.Weak[DomElement]*, bool](call = dom_element_by_id_map_remove_matches, context = element)
    _ = ak.vector_remove_all_matching(&entry.elements, predicate)

    if ak.vector_is_empty(&entry.elements):
        ak.hash_map_remove_opaque(&this.m_map, it)
        return

    if gc.weak_ptr(&entry.cached_first_element) == element:
        gc.weak_assign[DomElement](&entry.cached_first_element, none)

## Ported from ElementByIdMap.cpp:49 Web::DOM::ElementByIdMap::get.
pub func dom_element_by_id_map_get(this: const DomElementByIdMap*, element_id: ak.FlyString, scope_root: DomNode*) -> DomElement*?:
    # m_map is `mutable`: the cached first element is updated by this const lookup.
    let map = (DomElementByIdMap*)this
    let entry = ak.hash_map_get_k(&map.m_map, element_id) else return none

    if let element = gc.weak_ptr(&entry.cached_first_element):
        return element

    var first_element: DomElement*? = none
    for node in dom_node_inclusive_subtree(scope_root):
        let el = as_if_dom_element(node) else continue
        if dom_node_optional_fly_string_is(dom_element_id(el), element_id):
            first_element = el
            break

    if let element = first_element:
        gc.weak_assign[DomElement](&entry.cached_first_element, element)

    return first_element

## Ported from ElementByIdMap.cpp:74 Web::DOM::ElementByIdMap::for_each_element_with_id.
pub func dom_element_by_id_map_for_each_element_with_id(this: const DomElementByIdMap*, element_id: ak.StringView, scope_root: DomNode*, callback: ak.Function1[DomElement*, unit]):
    let map = (DomElementByIdMap*)this
    let entry = ak.hash_map_get_t_key[ak.FlyString, DomElementByIdMapMapEntry, ak.FlyStringTraits, ak.StringView, DomFlyStringStringViewTraits](&map.m_map, element_id) else return
    let call = callback.call else trap("VERIFY: callback")

    if ak.vector_size(&entry.elements) == 1:
        if let element = gc.weak_ptr(ak.vector_at(&entry.elements, 0)):
            call(callback.context, element)
        return

    for node in dom_node_inclusive_subtree(scope_root):
        let el = as_if_dom_element(node) else continue
        if let id = dom_element_id(el):
            if ak.fly_string_eq_string_view(&id, element_id):
                call(callback.context, el)

## Ported from ElementByIdMap.h:23 Web::DOM::ElementByIdMap::for_each_id.
pub func dom_element_by_id_map_for_each_id(this: DomElementByIdMap*, callback: ak.Function1[ak.FlyString, unit]):
    let call = callback.call else trap("VERIFY: callback")
    let keys = ak.hash_map_keys(&this.m_map)
    for id in ak.vector_span_const(&keys):
        call(callback.context, id)