Как использовать boost :: serialization с вложенными структурами и минимальными изменениями кода? - PullRequest
Новая
       5

Как использовать boost :: serialization с вложенными структурами и минимальными изменениями кода?

3 голосов
/ 19 февраля 2020

В настоящее время мы используем POD, который хранится во вложенных структурах. Пример: 

#define MaxNum1 100;
#define MaxNum2 50;

struct A
{
    int Value[MaxNum1]; 
    char SomeChar = 'a';
};

struct B
{
    A data[MaxNum2];
    float SomeFloat = 0.1f;
};


int main()
{
    B StructBObject = {};
}

Мы хотим улучшить наши структуры данных, используя std :: vector так: 

struct NewA
{
    std::vector<int> Value; 
    char SomeChar = 'a';
};

struct NewB
{
    std::vector<NewA> data;
    float SomeFloat = 0.1f;
};

int main()
{
    NewB StructNewBObject = {};
}

Единственный аргумент против этой модификации - это NewA и NewB больше не являются POD, и это делает чтение / запись в файл более сложным.

Как можно читать / писать NewA и NewB в файл, используя boost::serialization с минимальными изменениями кода для NewA и NewB? Минимальные изменения кода важны, потому что мы используем, например, большие структуры, которые имеют до 7 вложенных уровней.

1 Ответ

3 голосов
/ 20 февраля 2020

Вы можете сериализовать с помощью ускоренной сериализации¹: 

template <typename Ar> void serialize(Ar& ar, A& a, unsigned) {
    ar & a.Value & a.SomeChar;
}
template <typename Ar> void serialize(Ar& ar, B& b, unsigned) {
    ar & b.data & b.SomeFloat;
}

Используя их, вы уже будете иметь правильное поведение из коробки с C -array и std: : vector подходит.

Если вы хотите продолжать использовать тривиально копируемые типы фиксированного размера², вы можете использовать что-то вроде Boost Container static_vector: он будет отслеживать текущий размер, но данные статически выделяются прямо внутри структур.

TRIPLE DEMO

Вот тройная демонстрационная программа с тремя реализациями в зависимости от переменной IMPL.

Как вы можете видеть большую часть кода сохраняется инвариантным Однако для «лучшего сравнения» я убедился, что все контейнеры имеют половинную емкость (50/25) перед сериализацией.

Основная программа также десериализуется.

Live On Coliru 

#include <boost/iostreams/device/back_inserter.hpp>
#include <boost/iostreams/device/array.hpp>
#include <boost/iostreams/stream.hpp>

#include <boost/archive/binary_oarchive.hpp>
#include <boost/archive/binary_iarchive.hpp>

#include <boost/serialization/access.hpp>
#include <boost/serialization/is_bitwise_serializable.hpp>
#include <boost/serialization/binary_object.hpp>

#include <iostream>

#if (IMPL==0) // C arrays
    struct A {
        int Value[100]; 
        char SomeChar = 'a';
    };

    struct B {
        A data[50];
        float SomeFloat = 0.1f;
    };

    template <typename Ar> void serialize(Ar& ar, A& a, unsigned) {
        ar & a.Value & a.SomeChar;
    }
    template <typename Ar> void serialize(Ar& ar, B& b, unsigned) {
        ar & b.data & b.SomeFloat;
    }

#elif (IMPL==1) // std::vector
    #include <boost/serialization/vector.hpp>
    struct A {
        std::vector<int> Value;
        char SomeChar = 'a';
    };

    struct B {
        std::vector<A> data;
        float SomeFloat = 0.1f;
    };

    template <typename Ar> void serialize(Ar& ar, A& a, unsigned) {
        ar & a.Value & a.SomeChar;
    }
    template <typename Ar> void serialize(Ar& ar, B& b, unsigned) {
        ar & b.data & b.SomeFloat;
    }

#elif (IMPL==2) // static_vector
    #include <boost/serialization/vector.hpp>
    #include <boost/container/static_vector.hpp>
    struct A {
        boost::container::static_vector<int, 100> Value; 
        char SomeChar = 'a';
    };

    struct B {
        boost::container::static_vector<A, 50> data; 
        float SomeFloat = 0.1f;
    };

    template <typename Ar> void serialize(Ar& ar, A& a, unsigned) {
        ar & boost::serialization::make_array(a.Value.data(), a.Value.size()) & a.SomeChar;
    }
    template <typename Ar> void serialize(Ar& ar, B& b, unsigned) {
        ar & boost::serialization::make_array(b.data.data(), b.data.size()) & b.SomeFloat;
    }

#endif

namespace bio = boost::iostreams;
static constexpr auto flags = boost::archive::archive_flags::no_header;
using BinaryData = std::vector</*unsigned*/ char>;

int main() {
    char const* impls[] = {"C style arrays", "std::vector", "static_vector"};
    std::cout << "Using " << impls[IMPL] << " implementation: ";
    BinaryData serialized_data;

    {
        B object = {};
#if IMPL>0
        {
            // makes sure all containers half-full
            A element;
            element.Value.resize(50);
            object.data.assign(25, element);
        }
#endif

        bio::stream<bio::back_insert_device<BinaryData>> os { serialized_data };
        boost::archive::binary_oarchive oa(os, flags);

        oa << object;
    }

    std::cout << "Size: " << serialized_data.size() << "\n";

    {
        bio::array_source as { serialized_data.data(), serialized_data.size() };
        bio::stream<bio::array_source> os { as };
        boost::archive::binary_iarchive ia(os, flags);

        B object;
        ia >> object;
    }
}

Печать 

Using C style arrays implementation: Size: 20472
Using std::vector implementation: Size: 5256
Using static_vector implementation: Size: 5039

Заключительные мысли

См. Также:

¹ (но следует учитывать переносимость , как вы, вероятно, уже знакомы с подходом POD, см. C ++ Boost :: serialization: как мне заархивировать объект в одной программе и восстановить его в другой? )

² не POD Как и в случае NSMI, ваши типы не были POD

...