Method Deserialize

src/algorithm/ivf.cpp:618–690

    (reader).PopSeek();

void
IVF::Deserialize(StreamReader& reader) {
    // try to deserialize footer (only in new version)
    auto footer = Footer::Parse(reader);

    BufferStreamReader buffer_reader(
        &reader, std::numeric_limits<uint64_t>::max(), this->allocator_);

    if (footer == nullptr) {  // old format, DON'T EDIT, remove in the future
        logger::debug("parse with v0.14 version format");

        StreamReader::ReadObj(buffer_reader, this->total_elements_);
        StreamReader::ReadObj(buffer_reader, this->use_reorder_);
        StreamReader::ReadObj(buffer_reader, this->is_trained_);

        this->bucket_->Deserialize(buffer_reader);
        this->partition_strategy_->Deserialize(buffer_reader);
        this->label_table_->Deserialize(buffer_reader);
        if (use_reorder_) {
            this->reorder_codes_->Deserialize(buffer_reader);
        }

        if (use_attribute_filter_) {
            this->attr_filter_index_->Deserialize(buffer_reader);
            this->has_attribute_ = true;
        }
    } else {  // create like `else if ( ver in [v0.15, v0.17] )` here if need in the future
        logger::debug("parse with new version format");

        auto metadata = footer->GetMetadata();
        if (metadata->EmptyIndex()) {
            return;
        }

        auto basic_info = metadata->Get(BASIC_INFO);
        this->total_elements_ = basic_info["total_elements"].GetInt();
        this->use_reorder_ = basic_info["use_reorder"].GetBool();
        this->is_trained_ = basic_info["is_trained"].GetBool();
        if (basic_info.Contains(INDEX_PARAM)) {
            auto param_str = basic_info[INDEX_PARAM].GetString();
            auto index_param = std::make_shared<IVFParameter>();
            index_param->FromString(param_str);
            if (not this->create_param_ptr_->CheckCompatibility(index_param)) {
                auto message = fmt::format("IVF index parameter not match, current: {}, new: {}",
                                           this->create_param_ptr_->ToString(),
                                           index_param->ToString());
                logger::error(message);
                throw VsagException(ErrorType::INVALID_ARGUMENT, message);
            }
        }

        JsonType datacell_offsets = metadata->Get(DATACELL_OFFSETS);
        logger::debug("datacell_offsets: {}", datacell_offsets.Dump());
        JsonType datacell_sizes = metadata->Get(DATACELL_SIZES);
        logger::debug("datacell_sizes: {}", datacell_sizes.Dump());

        READ_DATACELL_WITH_NAME(buffer_reader, "bucket", this->bucket_);
        READ_DATACELL_WITH_NAME(buffer_reader, "partition_strategy", this->partition_strategy_);