Сериализация CString

@Suares · Регистрация: 28.02.2013

У меня есть структура Person:

C++

struct Person
{
    //BOOST_SERIALIZATION_SPLIT_MEMBER();
 
public:
    Person::Person(const WTL::CString& name = "", const WTL::CString& num = "", const WTL::CString& birthday = "", const WTL::CString& address = "")
        : _name(name), _phoneNumber(num), _birthday(birthday), _address(address)
    {
    }
 
    WTL::CString _name;
    WTL::CString _phoneNumber;
    WTL::CString _birthday;
    WTL::CString _address;
 
private:
    friend class boost::serialization::access;
 
    template<typename Archive>
    void serialize(Archive& ar, Person& p, const unsigned int version)
    {
        split_free(ar, p._name, version);
        split_free(ar, p._phoneNumber, version);
        split_free(ar, p._birthday, version);
        split_free(ar, p._address, version);
    }
};

Не могу разобраться с функцией serialize для CString. Вот именно нужен CString. Как она дожна быть реализована для CString?
Далее в классе ContactList я хочу записать в файл и считать с него множество контактов:

C++

class ContactList
{
public:
    ContactList();
    ~ContactList();
 
    void LoadPerons();
    void SavePersons();
 
    void AddPerson(const Person& p);
    void DeletePerson(const int id);
 
    Person GetPerson(size_t id);
    size_t GetSize() const;
 
private:
    std::vector<Person> _list;
};
 
void ContactList::LoadPerons()
{
    std::ifstream file("ContactList.txt");
    boost::archive::text_iarchive ia(file);
 
    ia >> _list;
}
 
void ContactList::SavePersons()
{
    std::ofstream file("ContactList.txt");
    boost::archive::text_oarchive oa(file);
 
    oa << _list;
}

Я хотя бы что-то правильно делаю?

@Avazart · 07.10.2014, 00:00

Хотел создать свою тему, но увидел что есть похожая по этому подниму ...

Сообщение от Suares

Вот именно нужен CString.

Мой вопрос в конкретной формулировке звучит так как сериализовать UnicodeString- тип строки из VCL (C++Builder).
Такой же вопрос можно задать и для QString из Qt или другого типа который предоставляется теми или иными библиотеками или фреймворками и в код которого мы не можем вмешивать по очевидным причинам.

Единственное что я нашел http://www.boost.org/doc/libs/1_56_0...trusiveversion

C++

namespace boost
{
    namespace serialization
    {
         template<class Archive>
         void serialize(Archive &ar,UnicodeString us,const unsigned int version)
         {
             /* ar & us; */
         }
    }
}

Но не понятно каким магическим образом можно объединить чтение и запись (иначе бы была возможность перевести UnicodeString к примеру в std::wstring сериализация которого имеется)

@ForEveR · 07.10.2014, 11:17

Avazart, Ну. save/load никто не мешает реализовать свободными, необязателен общий serialize.
Или же написать serialize, в котором вызвать

C++

1	boost::serialization::split_free

и отдельно save/load, как реализовано допустим в сериализации для std::complex.

Добавлено через 5 минут
Грубо говоря.

C++

namespace boost { namespace serialization {
 
template<typename Archive, typename T>
void serialize(Archive& ar, T& t, const unsigned int version)
{
    boost::serialization::split_free(ar, t, version);
}
 
template<typename Archive, typename T>
void save(Archive& ar, const T& t, const unsigned int)
{
   ar << t;
}
 
template<typename Archive, typename T>
void load(Archive& ar, T& t, const unsigned int)
{
   ar >> t;
}
 
}
 
}

+ возможно придется переопределить некоторые traits.

@Avazart · 07.10.2014, 15:35

Сообщение от ForEveR

+ возможно придется переопределить некоторые traits.

Ну со строками сложнее ситуация нежели с комплесным типом, traits в чем, для чего?

Добавлено через 7 минут
Пока я нашел решение через http://www.boost.org/doc/libs/1_56_0.../wrappers.html

C++

#include <boost/archive/text_oarchive.hpp>
#include <boost/archive/text_iarchive.hpp>
 
#include <boost/serialization/split_free.hpp>
#include <boost/serialization/binary_object.hpp>
 
BOOST_SERIALIZATION_SPLIT_FREE(UnicodeString)
BOOST_SERIALIZATION_SPLIT_FREE(AnsiString)
namespace boost {
    namespace serialization {
 
        template<class Archive>
        void save(Archive & ar, const UnicodeString& us, const unsigned int version)
        {
            const int size= us.Length()*sizeof(us[0]); // wchar_t
            ar & size;
            ar & boost::serialization::make_binary_object( const_cast<void*>(us.data()),
                                                                                                         size);
        }
 
        template<class Archive>
        void load(Archive & ar, UnicodeString& us, const unsigned int version)
        {
            int size;
            ar & size;
            us.SetLength(size/sizeof(us[0])); 
 
            ar & boost::serialization::make_binary_object( const_cast<void*>(us.data()),
                                                                                                         size);
        }
 
        template<class Archive>
        void save(Archive & ar, const AnsiString& as, const unsigned int version)
        {
            const int size= as.Length()*sizeof(as[0]); //  сhar
            ar & size;
            ar & boost::serialization::make_binary_object( const_cast<void*>(as.data()),
                                                                                                         size);
        }
 
        template<class Archive>
        void load(Archive & ar, AnsiString& as, const unsigned int version)
        {
            int size;
            ar & size;
            as.SetLength(size/sizeof(as[0])); 
 
            ar & boost::serialization::make_binary_object( const_cast<void*>(as.data()),
                                                                                                         size);
        }
    }
}

Работает, но не особо нравится, ибо если открыть файл видим набор символов, а не читабельный текст как хотелось бы ибо все таки используется text_archive. Но стоит заметить что std::wstring то же как-то выглядит не как хотелось бы в отличии от std::string.

@Dmitriy_M · 07.10.2014, 22:18

С QString когда то давно делал Boost C++ - сериализация boost, xml_woarchive, ошибка линкования
Но в последнем варианте вроде бы стал паковать в utf8 в std::string и сериализовать std::string.

Добавлено через 3 часа 28 минут
Вот последний вариант с QString

Кликните здесь для просмотра всего текста

C++ (Qt)

#include <QtCore/QDebug>
#include <QtCore/QString>
 
#include <vector>
#include <boost/serialization/nvp.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
#include <boost/serialization/vector.hpp>
 
#include <fstream>
 
namespace boost
{
    namespace serialization
    {
 
        template<class Archive>
        inline void save(Archive& ar, const QString& s,
                const unsigned int /*version*/)
        {
            auto ba = s.toUtf8();
            std::string str(ba.data(), ba.size());
 
            ar << make_nvp("QString", str);
        }
 
        template<class Archive>
        inline void load(Archive& ar, QString& s,
                const unsigned int /*version*/)
        {
            std::string str;
            ar >> make_nvp("QString", str);
            QByteArray ba(&str[0], str.size());
            s.append(ba);
        }
 
        template<class Archive>
        inline void serialize(Archive& ar, QString& s,
                const unsigned int file_version)
        {
            boost::serialization::split_free(ar, s, file_version);
        }
 
    } // namespace serialization
} // namespace boost
 
int main(int argc, char** argv)
{
    {
        std::ofstream ofs("test.xml");
        boost::archive::xml_oarchive oa(ofs);
        std::vector<QString> s =
        { "Ехал грека", "е№ґ1жњ€ж™Їж*ж*Ў" };
        oa << BOOST_SERIALIZATION_NVP(s);
        ofs.flush();
    }
 
    {
        std::ifstream ifs("test.xml");
        boost::archive::xml_iarchive ia(ifs);
        std::vector<QString> s;
        // restore the schedule from the archive
        ia >> BOOST_SERIALIZATION_NVP(s);
        for (auto str: s)
        {
            qDebug()<<str;
        }
    }
    return 0;
}

@Avazart · 08.10.2014, 18:35

Собственно в С++Buider можно использовать UTF8String в данных (есть неявное преобразование в UnicodeString и AnsiString по этому не создает неудобства)

Сериализация UTF8String в XML, С++Buider

C++

//---------------------------------------------------------------------------
#include <System.Classes.hpp> // UTF8String
#include <string>             // std::string
 
#include <boost/serialization/nvp.hpp>
#include <boost/archive/xml_iarchive.hpp>
#include <boost/archive/xml_oarchive.hpp>
//---------------------------------------------------------------------------
namespace boost
{
        namespace serialization
        {
                template<class Archive>
                inline void save(Archive& ar, const UTF8String& s,
                                const unsigned int /*version*/)
                {
                    std::string str= s.c_str();
                    ar << make_nvp("UTF8String", str);
                }
 
                template<class Archive>
                inline void load(Archive& ar, UTF8String& s,
                                const unsigned int /*version*/)
                {
                    std::string str;
                    ar >> make_nvp("UTF8String", str);
                    s=  str.c_str();
                }
 
                template<class Archive>
                inline void serialize(Archive& ar, UTF8String& s,
                                const unsigned int file_version)
                {
                    boost::serialization::split_free(ar, s, file_version);
                }
 
        } // namespace serialization
} // namespace boost
//---------------------------------------------------------------------------

	08.10.2014, 18:35

Опции темы