Method versioned_add

src/serialization/impl/opr_registry.cpp:184–223

}

void OprRegistryV2::versioned_add(
        const OprRegistryV2& record, uint8_t min_version, uint8_t max_version,
        bool dynamic) {
    mgb_assert(max_version >= min_version);

    auto&& sd = static_data();
    auto id = record.type_id;
    uint64_t type_id = id;
    //! record.type->name is nullptr when MGB_VERBOSE_TYPEINFO_NAME==0
#if MGB_VERBOSE_TYPEINFO_NAME
    if (dynamic && record.type && record.type->name) {
        type_id = MGB_HASH_RUNTIME(std::string(record.type->name));
    }
#endif
    for (uint8_t version = min_version; version <= max_version; version++) {
        auto&& registry_map = sd.version_id_reg_map[version];
        auto versioned_record = record;
        versioned_record.version = version;
        mgb_assert(
                registry_map.find(id) == registry_map.end() ||
                        id == dynamic_registry_v2()->type_id,
                "dduplicated OprRegistryV2 of %s\n", record.name.c_str());
        auto registry_ins = registry_map.emplace(id, versioned_record);
        if (!registry_ins.second) {
            //! the registry is dynamic
            mgb_assert(!record.converter);
            registry_map[id] = versioned_record;
        }
        //! sometimes the register id and the hash typeinfo is not same, just as
        //! dynamic Operator
        if (id != type_id) {
            mgb_assert(
                    registry_map.find(type_id) == registry_map.end(),
                    "duplicated OprRegistryV2 of %s\n", record.name.c_str());
            registry_map.emplace(type_id, versioned_record);
        }
        auto&& registry_type_map = sd.version_type_reg_map[version];
        registry_type_map.emplace(record.type, &registry_map[id]);
    }
}

void OprRegistry::add_using_dynamic_loader(
        Typeinfo* type, const std::string& name, const OprDumper& dumper) {