[C++] Binary serialization

[EclipsE]

Opet mi je bilo dosadno i igrao sam se sa serijalizacijom. Naravno, video sam ovakva rešenja:

ofs.write((char*)&obj, sizeof(obj));

U principu je radilo osim ako se unutar objekata nalaze neki pointeri, tada bi samo pisao adresu pointera a ne njegov sadržaj. Zato sam napravio BinarySerializer

BinarySerializer.h
BinarySerializer.cpp
BSTest

Još sam nov sa C++-om tako da je neke stvari možda bilo moguće uraditi na mnogo lakši način. Kako se ovo čudo koristi?

BinarySerializer b("filename");

b.serialize();
b << 1 << 2 << "test string";

b.deserialize();
int x, y;
string test;

b >> x >> y >> test;

cout << x << "\n" << y << "\n" << test.c_str();

b.closeFiles();

Ukoliko hoćemo neki objekat da serijalizujemo, možemo ovako:

class neka_klasa : public ISerializable
{
public: 
    // blablabla

protected:
    void Serialize(BinarySerializer* b)
    {
        b << x << y << z; // upisujemo potrebne informacije u fajl
    }

    void Deserialize(BinarySerializer* b)
    {
        b >> x >> y >> z; // citamo iz fajla
    }

    // prazan konstruktor je potreban, ako je protected onda mora da se doda i BinarySerializer kao friend
    neka_klasa() { }
    friend class BinarySerializer;
};

Može da se serializuje i std::vector kao što je pokazano u primeru. Verovatno ću se igrati malo da dodam i ostale STL containere

[Belphegor]

Interesantna tema i zanimljiv pristup serijalizaciji .
Probao sam malo i skratio ove dve metode:

BinarySerializer& BinarySerializer::operator<<(const std::string& str)
{
    unsigned int size = str.size();
    this->addData((char*)&size, sizeof(unsigned int));
    this->addData(str.c_str(), sizeof(char) * size);

    return *this;
}

BinarySerializer& BinarySerializer::operator>>(std::string& str)
{
    unsigned int length;
    this->readData(&length, sizeof(unsigned int));

    /*char* c_str = new char[length + 1];
    this->readData(c_str, sizeof(char) * length);
    c_str[length] = '\0';
    str = c_str;

    delete c_str;*/

    str.reserve(length);
    for(unsigned int i = 0; i < length; ++i)
        str.push_back(ifs.get());

    return *this;
}

mada ova druga malo "odskace" jer ne ide preko readData metode ali opet nigde ne pise da mora.
Ako uradis neke dodatke postavi.

[EclipsE]

Eh, tek sad vidim
Bila je greška u "BinarySerializer& BinarySerializer:: operator<<(const std::string& str)".

U početku sam hteo samo da upišem string tako što ću da idem kroz slova sve do prvog '\0', i da tako zapisem string.

for (i = 0; i < size && c[i]; i++);

A lepo sam mogao str.size() da iskoristim i da upišem ceo string
Što se tiče čitanja, ok je samo moraš da proveriš da li je fajl otvoren za deserijalizaciju (ako odradiš b.serialize() i probaš b >> nesto, trebalo bi da baci grešku).

EDIT: sad vidim, u principu i ne mora zato što će this->readData(&length, sizeof(unsigned int)); da se buni ako fajl nije otvoren za deserijalizaciju

[Belphegor]

Imam malih promena/poliranja i skidanja dlaka sa jajeta .
Izmenjeno 90% funkcija da budu "const-correct" i zamenjeni C-style cast-ovi u C++ cast-ove. Izmenjeno ime funkcije addData u writeData posto je ova druga readData pa rek'o...

Imao sam samo jedan problem kod jedne funkcije gde sam morao da "skinem" const type clarifier da bi radilo:

void BinarySerializer::writeData(const char* ptr, unsigned size) const
{
    assert(mode == 1);

    const_cast<std::ofstream& >(ofs).write(ptr, size);
}

BinarySerialization.h
BinarySerialization.cpp
BSTest.cpp

Mislim da nisam nista prevideo, ako jesam javi.

EDIT: Uuuuups. ima jedan cast previse:

void BinarySerializer::readData(char* ptr, unsigned size)
{
    assert(mode == 2);
    
    //ifs.read(reinterpret_cast<char*>(ptr), size);
    ifs.read(ptr, size);
}

Krenuo redom copy/paste i preterao.

[EclipsE]

Ne znam kako da serializujem map :\

Kada odradim nesto kao:

template <typename T, typename Y>
const BinarySerliazer& operator<<(const std::map<T, Y*>& mmap) const
{
    
}

ili čak i:

template <typename T>
const BinarySerializer& operator<<(const std::map<T, ISerializable*>& mmap) const
{
}

Ne mogu da pristupim ničemu u mmap

[Belphegor]

Mislis ne vidis sve clanove posle access operatora?
I kod mene je zabagovan VS tako da se ne oslanjam mnogo na intellisense.

[EclipsE]

Ma VS je totalno poludeo

[Belphegor]

Ja sam sad nesto probao da kompajliram i napola:

[EclipsE]

To se i meni desilo
Morao sam da obrišem sve iz /Debug/ i /ipch/ da bi hteo normalno da kompajlira.

[Belphegor]

Probao sam sto si rekao ali kod mene ne pomaze.
Napravio sam novi projekat i probao slicno i ne puca kompajler, sad cu da vidim postepeno 'de ga tacno boli.

[Sass Drake]

Imate li instalirane sve zakrpe za VS koje su izašle? AKo ne, pravac Windows Update.

[Belphegor]

Ako imas VS probaj kod sebe da ubacis u klasu:

template <typename T, typename Y>
const BinarySerliazer& operator << ( const std::map< T, Y* > & mmap ) const
{
}

I kad ne ubacim nista u telo funkcije opet puca, WTF

EDIT:
Nasao sam zasto puca, kopirao sam parce koda od EclipsE-a, pazi na ime tipa koji vraca:

template <typename T, typename Y> 
const BinarySerliazer& operator<<(const std::map<T, Y*>& mmap) const 
{      
}

a treba da bude:

BinarySerializer

i kompajler se zbunio.

[Belphegor]

Mislim da je ovo sto se tice std::map kontenera

template <typename T, typename Y>
    const BinarySerializer& operator << (const std::map< T, Y* > & mmap) const
    {
        unsigned int size = mmap.size();
        this->writeData(reinterpret_cast<char*>(&size), sizeof(unsigned int));
        std::map<T, Y*>::const_iterator itr = mmap.begin();
        for(; itr != mmap.end(); ++itr)
        {
            this->writeData(reinterpret_cast<const char*>(&(*itr).first), sizeof(T));
            this->writeData(*(*itr).second);
        }
        return *this;
    }

    template <typename T, typename Y>
    BinarySerializer& operator >> (std::map<T, Y*>& mmap)
    {
        unsigned int size;
        this->readData(reinterpret_cast<char*>(&size), sizeof(unsigned int));
        for(unsigned int i = 0; i < size; ++i)
        {
            T key;
            this->readData(reinterpret_cast<char*>(&key), sizeof(T));
            Y* py = new Y();
            *this >> *py;
            mmap[key] = py;
        }
        return *this;
    }

EDIT:
sta ako je key std::string?
Nista onda, se bogu da korisnik ove klase koristi samo primitivne tipove kao key.

[EclipsE]

Ne znam, ne mogu da napravim samo map<std::string, bilosta> :\
A čini mi se kao da sam negde vidjao da koriste std::string za map...

Evo ga nov test.

[Belphegor]

Jos jedna misao pre nego krenem na posao.
Moze samo da se ubace shift operatori umesto read/writeData i tako ako se ubaci neki "cudni" tip u map dobija se compile time error umesto runtime bug ako nema odgovarajueg overload-a operatora.

template <typename T, typename Y>
    const BinarySerializer& operator << (const std::map< T, Y* > & mmap) const
    {
        unsigned int size = mmap.size();
        this->writeData(reinterpret_cast<char*>(&size), sizeof(unsigned int));
        std::map<T, Y*>::const_iterator itr = mmap.begin();
        for(; itr != mmap.end(); ++itr)
        {
            //this->writeData(reinterpret_cast<const char*>(&(*itr).first), sizeof(T));
            *this << (*itr).first;
            this->writeData(*(*itr).second);
        }
        return *this;
    }

    template <typename T, typename Y>
    BinarySerializer& operator >> (std::map<T, Y*>& mmap)
    {
        unsigned int size;
        this->readData(reinterpret_cast<char*>(&size), sizeof(unsigned int));
        for(unsigned int i = 0; i < size; ++i)
        {
            T key;
            //this->readData(reinterpret_cast<char*>(&key), sizeof(T));
            *this >> key;
            Y* py = new Y();
            *this >> *py;
            mmap[key] = py;
        }
        return *this;
    }

Mada bi ja izbacio kontenere iz klase i radio to sa njima van nje i specijalizovao usko za moje potrebe. Jako je tesko napisati genericki kod koji bi resio svaku situaciju.

[EclipsE]

I size moze da se upise kao:

unsigned int size = mmap.size();
*this << size;

Dodah jos jednu funkciju za slucajeve kada Y nije ptr.

// <<
    template <typename T, typename Y>
    const BinarySerializer& operator << (const std::map< T, Y* > & mmap) const
    {
        unsigned int size = mmap.size();
        *this << size;

        std::map<T, Y*>::const_iterator itr = mmap.begin();

        for(; itr != mmap.end(); ++itr)
        {
            *this << itr->first;
            *this << *(itr->second);
        }
        return *this;
    }

    template <typename T, typename Y>
    const BinarySerializer& operator << (const std::map< T, Y > & mmap) const
    {
        unsigned int size = mmap.size();
        *this << size;

        std::map<T, Y>::const_iterator itr = mmap.begin();

        for(; itr != mmap.end(); ++itr)
        {
            *this << itr->first;
            *this << itr->second;
        }
        return *this;
    }

// >>
    template <typename T, typename Y>
    BinarySerializer& operator >> (std::map<T, Y*>& mmap)
    {
        unsigned int size;
        *this >> size;

        for(unsigned int i = 0; i < size; ++i)
        {
            T key;

            *this >> key;
            Y* py = new Y();
            *this >> *py;
            mmap[key] = py;
        }
        return *this;
    }

    template <typename T, typename Y>
    BinarySerializer& operator >> (std::map<T, Y>& mmap)
    {
        unsigned int size;
        *this >> size;

        for(unsigned int i = 0; i < size; ++i)
        {
            T key;
            Y py;

            *this >> key;
            *this >> py;

            mmap[key] = py;
        }

        return *this;
    }

[Belphegor]

Mozda bi jednu stvar trebalo uzeti u obzir, sto se tice serijalizacije, posto se obicno to radi sa "malim" klasama tipa koje drze neke "atribute", jer sigurno necemo serij. resurse, a s'obzirom da su vec neko vreme u C++ standard ubaceni "Move Semantics, Rvalue References, and Perfect Forwarding" moze da se na dosta mesta izbegne dinamicko alociranje memorije, pogotovu sa malim objektima gde dolazi do fragmentacije memorije i s'tim pogorsavanje performansi, a da i ne spominjem da je pozivanje new/new[] operatora relativno spora operacija u odnosu kreiranja na stack-u a i u isto vreme te stavlja na dilemu koji objekat je odgovoran za alociranje/dealociranje i ostale probleme vezane za memoriju na heap-u, najpametnije je, normalno gde je to moguce, ostaviti alokatorima koji su implementirani u same STL kontenere.
Tako da nema vise potreba za kontenerima koji drze pokazivace, samo je potrebno implementirti odgovarajuce metode u doticne klase - move "copy" konstruktor, move asignment operator...
Ja se tek jos upoznajem sa ovim inovacijama tako da ne bih jos objasnjavao o cemu se tacno radi i kako funkcionise dok to ne savladam 100%, najbolje da odgledas video sa linka koji sam ostavio, ako nisi do sada video, da vidim da li ce da te inspirise za neke nove ideje.