Method loadFromPython3

src/pystack/_pystack/pytypes.cpp:358–405

}

void
DictObject::loadFromPython3(remote_addr_t addr)
{
    Structure<py_dict_v> dict(d_manager, addr);

    ssize_t num_items;
    std::vector<Python3::PyDictKeyEntry> valid_entries;

    getDictEntries(d_manager, dict, num_items, valid_entries);

    // Copy the keys
    d_keys.reserve(valid_entries.size());
    std::transform(
            valid_entries.cbegin(),
            valid_entries.cend(),
            std::back_inserter(d_keys),
            [](auto& entry) { return (remote_addr_t)entry.me_key; });

    /* The DictObject can be in one of two forms.
     *
     *          Either:
     *  A combined table:
     *  ma_values == NULL, dk_refcnt == 1.
     *  Values are stored in the me_value field of the PyDictKeysObject.
     *          Or:
     *  A split table:
     *  ma_values != NULL, dk_refcnt >= 1
     *  Values are stored in the ma_values array.
     *          Only string (unicode) keys are allowed.
     *          All dicts sharing same key must have same insertion order.
     */

    remote_addr_t dictvalues_addr = dict.getField(&py_dict_v::o_ma_values);
    Structure<py_dictvalues_v> dictvalues(d_manager, dictvalues_addr);

    // Get the values in one copy if we are dealing with a split-table dictionary
    if (dictvalues_addr != 0) {
        d_values.resize(num_items);
        auto values_addr = dictvalues.getFieldRemoteAddress(&py_dictvalues_v::o_values);
        d_manager->copyMemoryFromProcess(values_addr, num_items * sizeof(PyObject*), d_values.data());
    } else {
        std::transform(
                valid_entries.cbegin(),
                valid_entries.cend(),
                std::back_inserter(d_values),
                [](auto& entry) { return (remote_addr_t)entry.me_value; });
    }
}

void
DictObject::loadFromPython2(remote_addr_t addr)