deserializer.h

Go to the documentation of this file.

#pragma once
 
#include <memory>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "assert.h"
#include "reader.h"
 
namespace kuzu {
namespace common {
 
class Deserializer {
public:
    explicit Deserializer(std::unique_ptr<Reader> reader) : reader(std::move(reader)) {}
 
    bool finished() const { return reader->finished(); }
 
    template<typename T>
        requires std::is_trivially_destructible_v<T> || std::is_same_v<std::string, T>
    void deserializeValue(T& value) {
        reader->read(reinterpret_cast<uint8_t*>(&value), sizeof(T));
    }
 
    void read(uint8_t* data, uint64_t size) { reader->read(data, size); }
 
    void validateDebuggingInfo(std::string& value, std::string expectedVal);
 
    template<typename T>
    void deserializeOptionalValue(std::unique_ptr<T>& value) {
        bool isNull;
        deserializeValue(isNull);
        if (!isNull) {
            value = T::deserialize(*this);
        }
    }
 
    template<typename T1, typename T2>
    void deserializeUnorderedMap(std::unordered_map<T1, std::unique_ptr<T2>>& values) {
        uint64_t mapSize;
        deserializeValue<uint64_t>(mapSize);
        values.reserve(mapSize);
        for (auto i = 0u; i < mapSize; i++) {
            T1 key;
            deserializeValue<T1>(key);
            auto val = T2::deserialize(*this);
            values.emplace(key, std::move(val));
        }
    }
 
    template<typename T>
    void deserializeVector(std::vector<T>& values) {
        uint64_t vectorSize;
        deserializeValue(vectorSize);
        values.resize(vectorSize);
        for (auto& value : values) {
            if constexpr (requires(Deserializer& deser) { T::deserialize(deser); }) {
                value = T::deserialize(*this);
            } else {
                deserializeValue(value);
            }
        }
    }
 
    template<typename T, uint64_t ARRAY_SIZE>
    void deserializeArray(std::array<T, ARRAY_SIZE>& values) {
        KU_ASSERT(values.size() == ARRAY_SIZE);
        for (auto& value : values) {
            if constexpr (requires(Deserializer& deser) { T::deserialize(deser); }) {
                value = T::deserialize(*this);
            } else {
                deserializeValue(value);
            }
        }
    }
 
    template<typename T>
    void deserializeVectorOfPtrs(std::vector<std::unique_ptr<T>>& values) {
        uint64_t vectorSize;
        deserializeValue(vectorSize);
        values.resize(vectorSize);
        for (auto i = 0u; i < vectorSize; i++) {
            values[i] = T::deserialize(*this);
        }
    }
 
    template<typename T>
    void deserializeUnorderedSet(std::unordered_set<T>& values) {
        uint64_t setSize;
        deserializeValue(setSize);
        for (auto i = 0u; i < setSize; i++) {
            T value;
            deserializeValue<T>(value);
            values.insert(value);
        }
    }
 
private:
    std::unique_ptr<Reader> reader;
};
 
template<>
void Deserializer::deserializeValue(std::string& value);
 
} // namespace common
} // namespace kuzu