Уменьшить объем сериализации - C/C++

Есть объект, отвечающий за усреднение значений

template <typename T, uint N = 32>
class Averager {
private :
    friend class boost::serialization::access;

    std::deque<T> m_deque;
    uint64 m_sum;
    uint m_size;

    template <class Archive>
    void serialize (Archive& archive, const uint version)
    {
        archive & BOOST_SERIALIZATION_NVP (m_deque);
        archive & BOOST_SERIALIZATION_NVP (m_sum);
        archive & BOOST_SERIALIZATION_NVP (m_size);
    }

public :
    explicit Averager(uint size = N) : m_sum (0), m_size (size) {}
    ~Averager() {}

    Averager& operator += (const Averager& rhs)
    {
        (*this) << rhs.avg();
        return *this;
    }
    void avg (uint size)
    {
        m_sum = 0;
        m_deque.clear();
        m_size = size;
    }
    T avg (void) const
    {
        if (!m_deque.size()) return 0;
        return (T)(m_sum / m_deque.size());
    }
    Averager& operator << (const T& value)
    {
        if (m_size)
        {
            if (m_deque.size() == m_size)
            {
                m_sum -= (*(m_deque.begin()));
                m_deque.pop_front();
            }
            m_sum += value;
            m_deque.push_back(value);
        }
        return *this;
    }   
};

есть объект его использующий

class Item {
private :
    friend class boost::serialization::access;
    typedef Averager<uint> TAverager;
    static const uint AVERAGE = 1000;

    time_t m_time;
    TAverager m_values;

    template <class Archive>
    void serialize (Archive& archive, const uint version)
    {
        archive & BOOST_SERIALIZATION_NVP (m_time);
        archive & BOOST_SERIALIZATION_NVP (m_values);
    }

public :
    Item () : m_time (0), m_values(AVERAGE) {}
    ~Item() {}

    time_t  time (void) const { return m_time;          }
    uint    value(void) const { return m_values.avg();  }

    bool operator < (const Item& rhs) const { return m_time < rhs.m_time; }
    Item& operator << (uint value)
    {
        m_time  =  ::time();
        m_values << value;
        return *this;
    }
};

Так вот если усреднять по очень большому числу значений, то сериализуется весь std::deque.
В результате получаются килобайты, ходя реально интерисует время и усредненное значение (тоесть несколько байт).

Сам дек целиком нужен лишь с одной стороны. Если его передать, сереализовав данные, то на другой нужно лишь усредненное.
Можно ли как сделать, чтоб при сериализации бралось лишь усредненное значение, а при десериализации оно и использовалось для инициализации дека ?

P.S. И хотелось бы это сделать не как в Averager, так и в Item (тоесть двумя способами на выбор)

Здравствуйте, k732, Вы писали:
K>Сам дек целиком нужен лишь с одной стороны. Если его передать, сереализовав данные, то на другой нужно лишь усредненное.
K>Можно ли как сделать, чтоб при сериализации бралось лишь усредненное значение, а при десериализации оно и использовалось для инициализации дека ?

А если разделить чтение и запись как здесь
Splitting serialize into save/load

Здравствуйте, Vinick, Вы писали:

V>Здравствуйте, k732, Вы писали:
K>>Сам дек целиком нужен лишь с одной стороны. Если его передать, сереализовав данные, то на другой нужно лишь усредненное.
K>>Можно ли как сделать, чтоб при сериализации бралось лишь усредненное значение, а при десериализации оно и использовалось для инициализации дека ?

V>А если разделить чтение и запись как здесь
V>Splitting serialize into save/load

И не забываем про второй параметр метода serialize
пускай если version = 1, то сериализуем среднее иначе весь объект

Здравствуйте, agolubtsov, Вы писали:

A>Здравствуйте, Vinick, Вы писали:

V>>Здравствуйте, k732, Вы писали:
K>>>Сам дек целиком нужен лишь с одной стороны. Если его передать, сереализовав данные, то на другой нужно лишь усредненное.
K>>>Можно ли как сделать, чтоб при сериализации бралось лишь усредненное значение, а при десериализации оно и использовалось для инициализации дека ?

V>>А если разделить чтение и запись как здесь
V>>Splitting serialize into save/load

A>И не забываем про второй параметр метода serialize
A>пускай если version = 1, то сериализуем среднее иначе весь объект

ну впринципе идея понятна. Только
1. Как сериализатору указать версию (желательно, чтоб полностью сериализовалось по умолчанию)
2. Я так понимаю, что нужно что-то вроде

    template<class Archive>
    void save (Archive& archive, const unsigned int version) const
    {
        archive & m_time;
        archive & (!version) ? m_values : m_values.avg();
    }
    template<class Archive>
    void load (Archive& archive, const unsigned int version)
    {
        archive & m_time;
        archive & (!version) ? m_values : ... ?;
    }

тоесть для сериализации понятно: если version = 0, то сериализуем весь объект, иначе только среднее значение (int)
А вот при десереализации если 0, то опять весь контейнер, а вот если не 0, то нужно как-то проинициализировать объект руками.

Вот здесь я просто не понял как

Здравствуйте, k732, Вы писали:

K>тоесть для сериализации понятно: если version = 0, то сериализуем весь объект, иначе только среднее значение (int)
K>А вот при десереализации если 0, то опять весь контейнер, а вот если не 0, то нужно как-то проинициализировать объект руками.

K>Вот здесь я просто не понял как

Не совсем понятно зачем инициализировать то что получателю не требуется. Может проще ввести в Averager поле m_avg и какой-нибудь флаг сигнализирующий о валидности этого поля.
Но если очень хочется иметь заполненый контейнер, то так:

    template<class Archive>
    void save (Archive& archive, const unsigned int version) const
    {
        archive & version;
                archive & m_time;
                if(!version)
                   archive & m_values;
                else
                  {
                     archive & m_values.deque_size();
                     archive & m_values.avg();
                  }
    }
    template<class Archive>
    void load (Archive& archive, const unsigned int)
    {
                int version;
                archive & version;
        archive & m_time;
                if(!version)
                     archive & m_values;
                else
                   {
                       uint sz;
                       double avg;
                       archive & sz;
                       archive & avg;
                       m_values.avg(sz);
                       std::fill_(std::ostream_iterator<double>(m_values),sz,avg);
                       // или если сохранение размера не важно m_values << avg,
                       // тогда передавать m_values.deque_size() нет необходимости
                    }
    }

Здравствуйте, Vinick, Вы писали:

V>Здравствуйте, k732, Вы писали:

K>>тоесть для сериализации понятно: если version = 0, то сериализуем весь объект, иначе только среднее значение (int)
K>>А вот при десереализации если 0, то опять весь контейнер, а вот если не 0, то нужно как-то проинициализировать объект руками.

K>>Вот здесь я просто не понял как

V>Не совсем понятно зачем инициализировать то что получателю не требуется. Может проще ввести в Averager поле m_avg и какой-нибудь флаг сигнализирующий о валидности этого поля.
V>Но если очень хочется иметь заполненый контейнер, то так:
V>

V>    template<class Archive>
V>    void save (Archive& archive, const unsigned int version) const
V>    {
V>        archive & version;
V>                archive & m_time;
V>                if(!version)
V>                   archive & m_values;
V>                else
V>                  {
V>                     archive & m_values.deque_size();
V>                     archive & m_values.avg();
V>                  }
V>    }
V>    template<class Archive>
V>    void load (Archive& archive, const unsigned int)
V>    {
V>                int version;
V>                archive & version;
V>        archive & m_time;
V>                if(!version)
V>                     archive & m_values;
V>                else
V>                   {
V>                       uint sz;
V>                       double avg;
V>                       archive & sz;
V>                       archive & avg;
V>                       m_values.avg(sz);
V>                       std::fill_(std::ostream_iterator<double>(m_values),sz,avg);
V>                       // или если сохранение размера не важно m_values << avg,
V>                       // тогда передавать m_values.deque_size() нет необходимости
V>                    }
V>    }
V>

спасибо. я правда уже немного по-другому сделал

    template<class Archive>
    void save (Archive& archive, const unsigned int version) const
    {
        archive << m_time;
        if (version)
        {
            TAverager temp (1);
            temp << m_values.avg();
            archive << temp;
        }
        else archive << m_power;
    }
    template<class Archive>
    void load (Archive& archive, const unsigned int version)
    {
        archive >> m_time;
        if (version)
        {
            TAverager temp (1);
            archive >> temp;
            m_values << temp.avg();
        }
        else archive >> m_power;
    }

я так понимаю, что осталось выбрать версию
BOOST_SERIALIZATION_SPLIT_MEMBER()
...
BOOST_CLASS_VERSION (Item, 1)

но получается, что это на этапе компиляции. Тоесть при сериализации всегда пойдет только усредненное значение.
А можно ли на этапе выполнения выбирать ?

V>    template<class Archive>
V>    void save (Archive& archive, const unsigned int version) const
V>    {
V>        archive & version;
V>                archive & m_time;
V>                if(!version)
V>                   archive & m_values;
V>                else
V>                  {
V>                     archive & m_values.deque_size();
V>                     archive & m_values.avg();
V>                  }
V>    }
V>    template<class Archive>
V>    void load (Archive& archive, const unsigned int)
V>    {
V>                int version;
V>                archive & version;
V>        archive & m_time;
V>                if(!version)
V>                     archive & m_values;
V>                else
V>                   {
V>                       uint sz;
V>                       double avg;
V>                       archive & sz;
V>                       archive & avg;
V>                       m_values.avg(sz);
V>                       std::fill_(std::ostream_iterator<double>(m_values),sz,avg);
V>                       // или если сохранение размера не важно m_values << avg,
V>                       // тогда передавать m_values.deque_size() нет необходимости
V>                    }
V>    }
V>

и зачем сериализовать саму версию ?

Здравствуйте, k732, Вы писали:

K>и зачем сериализовать саму версию ?
А как получатель узнает о том какой объект лежит в архиве?

Здравствуйте, Vinick, Вы писали:

V>Здравствуйте, k732, Вы писали:

K>>и зачем сериализовать саму версию ?
V>А как получатель узнает о том какой объект лежит в архиве?
Понятно. Принимается...

Есть еще вопросы
1. Почему я не могу сериализовать данные контейнера.

V>                else
V>                  {
V>                     archive & m_values.size();  // size добавил
V>                     archive & m_values.avg();
V>                  }

>*.h(152) : error C2664: 'boost::serialization::make_nvp' : cannot convert parameter 2 from 'unsigned int' to 'unsigned int &'
1>        C:\BOOST\boost_1_35_0\boost/serialization/access.hpp(93) : see reference to function template instantiation 'void Averager<T>::save<Archive>(Archive &,const unsigned int) const' being compiled
1>        with
1>        [
1>            T=uint,
1>            Archive=boost::archive::binary_oarchive
1>        ]
1>        C:\BOOST\boost_1_35_0\boost/serialization/split_member.hpp(43) : see reference to function template instantiation 'void boost::serialization::access::member_save<Archive,const T>(Archive &,T &,const unsigned int)' being compiled
1>        with
1>        [
1>            Archive=boost::archive::binary_oarchive,
1>            T=Averager<uint>
1>        ]
...

а получается только так

            value_type avg = this->avg();
            uint size = m_m_values.size();
            archive & BOOST_SERIALIZATION_NVP (size);
            archive & BOOST_SERIALIZATION_NVP (avg);

В чем разница ?

2.Хчется сериализовать Averager

Сериализация зависит от версии. Ее нужно задать как
BOOST_CLASS_VERSION (SomeClass, version)

Для нешаблонных классов получается задавать версию, но Averager шаблонный и не понятно как для него вызвать
BOOST_CLASS_VERSION. Тоесть нужно как-то указать для всех типов.

Можно или нет ?

Здравствуйте, k732, Вы писали:

[крик души]
Сволочная бустовская сериализация.
[/крик души]

Здравствуйте, NikeByNike, Вы писали:

NBN>Здравствуйте, k732, Вы писали:

NBN>[крик души]
NBN>Сволочная бустовская сериализация.
NBN>[/крик души]

ну это не решпет вышеописанные проблеммы

ну где Вы, корифеи ? (сейчас правда принято Guru

Странно конечно, что такой мощнейший форум (вывод сделал по некоторым индивидумам)
и так не активен в последнее время. Он доживает ?

Если да, то где сейчас все тусуются, если нет, то где кипящая жизнь, обмен опытом...

Или все к футболу готовятся ?

Здравствуйте, agolubtsov, Вы писали:

A>И не забываем про второй параметр метода serialize
A>пускай если version = 1, то сериализуем среднее иначе весь объект

Проблема в том, что версия записывается только один раз на тип. И в этом заключается большая подстава.

Здравствуйте, NikeByNike, Вы писали:

NBN>Здравствуйте, agolubtsov, Вы писали:

A>>И не забываем про второй параметр метода serialize
A>>пускай если version = 1, то сериализуем среднее иначе весь объект

NBN>Проблема в том, что версия записывается только один раз на тип. И в этом заключается большая подстава.
Ну пусть хоьб 1 раз. Но проблемма в шаблонном классе. Можно ли ее разрешить ?

Здравствуйте, k732, Вы писали:

А если ввести флажок — обозначающий содержимое твоего Averager и при необходимости итема:

    std::deque<T> m_deque;
    uint64 m_sum;
    uint m_size;
    bool m_use_only_mean;

    template <class Archive>
    void serialize (Archive& archive, const uint version)
    {
        archive & BOOST_SERIALIZATION_NVP (m_use_only_mean);
        if ( !m_use_only_mean )
            archive & BOOST_SERIALIZATION_NVP (m_deque);
        archive & BOOST_SERIALIZATION_NVP (m_sum);
        archive & BOOST_SERIALIZATION_NVP (m_size);
    }

Такое тебе не годится?

Здравствуйте, NikeByNike, Вы писали:

NBN>Здравствуйте, k732, Вы писали:

NBN>А если ввести флажок — обозначающий содержимое твоего Averager и при необходимости итема:
NBN>

NBN>    std::deque<T> m_deque;
NBN>    uint64 m_sum;
NBN>    uint m_size;
NBN>    bool m_use_only_mean;

NBN>    template <class Archive>
NBN>    void serialize (Archive& archive, const uint version)
NBN>    {
NBN>        archive & BOOST_SERIALIZATION_NVP (m_use_only_mean);
NBN>        if ( !m_use_only_mean )
NBN>            archive & BOOST_SERIALIZATION_NVP (m_deque);
NBN>        archive & BOOST_SERIALIZATION_NVP (m_sum);
NBN>        archive & BOOST_SERIALIZATION_NVP (m_size);
NBN>    }


NBN>

NBN>Такое тебе не годится?
как вариант конечно можно
ну раз пошла пьянка с бустом, что хотелось бы разобраться...

Здравствуйте, k732, Вы писали:

K>Если да, то где сейчас все тусуются, если нет, то где кипящая жизнь, обмен опытом...
Да просто все тебя жалеют и не дают советы, типа, выпрями таки дизайн и сделать так, чтобы сериализация была отдельно, а модификация данных отдельно...

k732 пишет:

> Ну пусть хоьб 1 раз. Но проблемма в шаблонном классе. Можно ли ее
> разрешить ?

Попробуй ченить в таком роде:

namespace boost { namespace serialization {
template<typename T, unsigned int X> struct version<Averager<T, X> >
{
    typedef mpl::int_<20> type;
    typedef mpl::integral_c_tag tag;
    BOOST_STATIC_CONSTANT(unsigned int, value=version::type::value);
};
}}

Не знаю, на кой ляд там mpl-ные штуки, наверное можно написать просто

namespace boost { namespace serialization {
template<typename T, unsigned int X> struct version<Averager<T, X> >
{
     enum { value = 20};
};
}}

Posted via RSDN NNTP Server 2.1 beta

Здравствуйте, Sergey, Вы писали:

S>Попробуй ченить в таком роде:
S>Не знаю, на кой ляд там mpl-ные штуки, наверное можно написать просто

Версия сохраняется только один раз, поэтому в общем случае её лучше применять для именно версионных целей.

NikeByNike пишет:

> S>Попробуй ченить в таком роде:
> S>Не знаю, на кой ляд там mpl-ные штуки, наверное можно написать просто
>
> Версия сохраняется только один раз, поэтому в общем случае её лучше
> применять для именно версионных целей.

Я честно говоря не разбирался, для чего там k732 версию применять
пытается. Понял, что она нужна для шаблонного класса, заглянул в
исходники и написал как ее на мой взгляд можноь применить не к классу, а
к шаблону — эта задача, по-моему, может не только у него возникнуть.
А уж будет в нее k732 собственно версию класть или какие-то левые
извраты, меня не касается.

Posted via RSDN NNTP Server 2.1 beta

Здравствуйте, Sergey, Вы писали:

S>k732 пишет:

>> Ну пусть хоьб 1 раз. Но проблемма в шаблонном классе. Можно ли ее
>> разрешить ?

S>Попробуй ченить в таком роде:
S>

S>namespace boost { namespace serialization {
S>template<typename T, unsigned int X> struct version<Averager<T, X> >
S>{
S>    typedef mpl::int_<20> type;
S>    typedef mpl::integral_c_tag tag;
S>    BOOST_STATIC_CONSTANT(unsigned int, value=version::type::value);
S>};
S>}}
S>

S>Не знаю, на кой ляд там mpl-ные штуки, наверное можно написать просто
S>

S>namespace boost { namespace serialization {
S>template<typename T, unsigned int X> struct version<Averager<T, X> >
S>{
S>     enum { value = 20};
S>};
S>}}
S>

большое тебе человеческое. Вроде сработало
Правда не совсем понятно зачем так сложно пришлось и что это означает (в смысле объяснения)

k732 пишет:

> S>namespace boost { namespace serialization {
> S>template<typename T, unsigned int X> struct version<Averager<T, X> >
> S>{
> S> typedef mpl::int_<20> type;
> S> typedef mpl::integral_c_tag tag;
> S> BOOST_STATIC_CONSTANT(unsigned int, value=version::type::value);
> S>};
> S>}}
> S>
>
>
>
> S>Не знаю, на кой ляд там mpl-ные штуки, наверное можно написать просто
> S>
>
> S>namespace boost { namespace serialization {
> S>template<typename T, unsigned int X> struct version<Averager<T, X> >
> S>{
> S> enum { value = 20};
> S>};
> S>}}
> S>
>
>
>
> большое тебе человеческое. Вроде сработало
> Правда не совсем понятно зачем так сложно пришлось и что это означает (в
> смысле объяснения)

Ну вообще если посмотреть в файл version.hpp, то там написано:

namespace boost {
namespace serialization {

struct basic_traits;

// default version number is 0. Override with higher version
// when class definition changes.
template<class T>
struct version
{
     template<class U>
     struct traits_class_version {
         typedef BOOST_DEDUCED_TYPENAME U::version type;
     };

     typedef mpl::integral_c_tag tag;
     // note: at least one compiler complained w/o the full qualification
     // on basic traits below
     typedef
         BOOST_DEDUCED_TYPENAME mpl::eval_if<
             is_base_and_derived<boost::serialization::basic_traits,T>,
             traits_class_version<T>,
             mpl::int_<0>
         >::type type;
     BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);
};

} // namespace serialization
} // namespace boost

Означает это, как и написано в комменте, что по дефолту версия равна 0.
Т.е., выражение boost::serialization::version<some_type>::value имеет
значение 0, если не определена соответствующая специализация. Макрос

#define BOOST_CLASS_VERSION(T, N)                                      \
namespace boost {                                                      \
namespace serialization {                                              \
template<>                                                             \
struct version<T >                                                     \
{                                                                      \
     typedef mpl::int_<N> type;                                         \
     typedef mpl::integral_c_tag tag;                                   \
     BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value); \
};                                                                     \
}                                                                      \
}

как раз и определяет такую специализацию. Соответственно, чтобы задать
версию для шаблона, можно написать частичную специализацию структуры
version — это код который я приводил в прошлый раз.

Зачем нужны typedef mpl::int_<N> type; и typedef mpl::integral_c_tag
tag; — понятия не имею, предполагаю что низачем.

Posted via RSDN NNTP Server 2.1 beta

Здравствуйте, Sergey, Вы писали:

S>k732 пишет:

>> S>namespace boost { namespace serialization {
>> S>template<typename T, unsigned int X> struct version<Averager<T, X> >
>> S>{
>> S> typedef mpl::int_<20> type;
>> S> typedef mpl::integral_c_tag tag;
>> S> BOOST_STATIC_CONSTANT(unsigned int, value=version::type::value);
>> S>};
>> S>}}
>> S>
>>
>>
>>
>> S>Не знаю, на кой ляд там mpl-ные штуки, наверное можно написать просто
>> S>
>>
>> S>namespace boost { namespace serialization {
>> S>template<typename T, unsigned int X> struct version<Averager<T, X> >
>> S>{
>> S> enum { value = 20};
>> S>};
>> S>}}
>> S>
>>
>>
>>
>> большое тебе человеческое. Вроде сработало
>> Правда не совсем понятно зачем так сложно пришлось и что это означает (в
>> смысле объяснения)

S>Ну вообще если посмотреть в файл version.hpp, то там написано:
S>

S>namespace boost {
S>namespace serialization {

S>struct basic_traits;

S>// default version number is 0. Override with higher version
S>// when class definition changes.
S>template<class T>
S>struct version
S>{
S>     template<class U>
S>     struct traits_class_version {
S>         typedef BOOST_DEDUCED_TYPENAME U::version type;
S>     };

S>     typedef mpl::integral_c_tag tag;
S>     // note: at least one compiler complained w/o the full qualification
S>     // on basic traits below
S>     typedef
S>         BOOST_DEDUCED_TYPENAME mpl::eval_if<
S>             is_base_and_derived<boost::serialization::basic_traits,T>,
S>             traits_class_version<T>,
S>             mpl::int_<0>
         >>::type type;
S>     BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value);
S>};

S>} // namespace serialization
S>} // namespace boost
S>

S>Означает это, как и написано в комменте, что по дефолту версия равна 0.
S>Т.е., выражение boost::serialization::version<some_type>::value имеет
S>значение 0, если не определена соответствующая специализация. Макрос

S>

S>#define BOOST_CLASS_VERSION(T, N)                                      \
S>namespace boost {                                                      \
S>namespace serialization {                                              \
S>template<>                                                             \
S>struct version<T >                                                     \
S>{                                                                      \
S>     typedef mpl::int_<N> type;                                         \
S>     typedef mpl::integral_c_tag tag;                                   \
S>     BOOST_STATIC_CONSTANT(unsigned int, value = version::type::value); \
S>};                                                                     \
S>}                                                                      \
S>}
S>

S>как раз и определяет такую специализацию. Соответственно, чтобы задать
S>версию для шаблона, можно написать частичную специализацию структуры
S>version — это код который я приводил в прошлый раз.

S>Зачем нужны typedef mpl::int_<N> type; и typedef mpl::integral_c_tag
S>tag; — понятия не имею, предполагаю что низачем.

еще раз спасибо

	От:	k732
	Дата:	20.06.08 03:31
	Оценка:

	От:	Vinick
	Дата:	20.06.08 04:37
	Оценка:

	От:	agolubtsov
	Дата:	20.06.08 05:11
	Оценка:

	От:	k732
	Дата:	20.06.08 07:05
	Оценка:

	От:	Vinick
	Дата:	20.06.08 07:38
	Оценка:

	От:	Erop
	Дата:	21.06.08 13:48
	Оценка:

	От:	Sergey
	Дата:	21.06.08 15:18
	Оценка:

	От:	Sergey
	Дата:	21.06.08 15:49
	Оценка:

	От:	Sergey
	Дата:	21.06.08 19:04
	Оценка:	1 (1)