bserialize.h

Go to the documentation of this file.

//
//  This file is part of DDC.
// 
//  DDC is free software: you can redistribute it and/or modify
//  it under the terms of the GNU Lesser General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
// 
//  DDC is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU Lesser General Public License for more details.
// 
//  You should have received a copy of the GNU Lesser General Public License
//  along with DDC.  If not, see <http://www.gnu.org/licenses/>.
//
// ==========  Dialing Syntax Analysis (www.aot.ru)
// ==========  Copyright by Alexey Sokirko, Bryan Jurish (2011)

#ifndef bserialze_h
#define bserialze_h

#include  "utilit.h"
        
// ============== DWORD =====================
inline size_t get_size_in_bytes (const DWORD& t)
{
    return sizeof(DWORD);
};
inline size_t save_to_bytes(const DWORD& i, BYTE* buf)
{
    *((DWORD*)buf) = i;
    return get_size_in_bytes(i);
}

inline size_t restore_from_bytes(DWORD& i, const BYTE* buf)
{
    i = *((DWORD*)buf);
    return get_size_in_bytes(i);
};



// ============== int =====================
inline size_t get_size_in_bytes (const int& t)
{
    return sizeof(int);
};
inline size_t save_to_bytes(const int& i, BYTE* buf)
{
    *((int*)buf) = i;
    return get_size_in_bytes(i);
}

inline size_t restore_from_bytes(int& i, const BYTE* buf)
{
    i = *((int*)buf);
    return get_size_in_bytes(i);
};


// ============== CHAR =====================
inline size_t get_size_in_bytes (const char& t)
{
    return 1;
};

inline size_t save_to_bytes(const char& i, BYTE* buf)
{
    *((char*)buf) = i;
    return get_size_in_bytes(i);
};

inline size_t restore_from_bytes(char& i, const BYTE* buf)
{
    i = *((char*)buf);
    return get_size_in_bytes(i);
};


// ============== BYTE =====================
inline size_t get_size_in_bytes (const BYTE& t)
{
    return 1;
};

inline size_t save_to_bytes(const BYTE& i, BYTE* buf)
{
    *((BYTE*)buf) = i;
    return get_size_in_bytes(i);
};

inline size_t restore_from_bytes(BYTE& i, const BYTE* buf)
{
    i = *((BYTE*)buf);
    return get_size_in_bytes(i);
};



// ============== WORD =====================
inline size_t get_size_in_bytes (const WORD& t)
{
    return 2;
};

inline size_t save_to_bytes(const WORD& i, BYTE* buf)
{
    *((WORD*)buf) = i;
    return get_size_in_bytes(i);
};

inline size_t restore_from_bytes(WORD& i, const BYTE* buf)
{
    i = *((WORD*)buf);
    return get_size_in_bytes(i);
};


// ============== QWORD =====================
inline size_t get_size_in_bytes (const QWORD& t)
{
    return 8;
};

inline size_t save_to_bytes(const QWORD& i, BYTE* buf)
{
    *((QWORD*)buf) = i;
    return get_size_in_bytes(i);
};

inline size_t restore_from_bytes(QWORD& i, const BYTE* buf)
{
    i = *((QWORD*)buf);
    return get_size_in_bytes(i);
};

// ============== DOUBLE =====================
inline size_t get_size_in_bytes (const double& t)
{
    return sizeof(t);
};
inline size_t save_to_bytes(const double& i, BYTE* buf)
{
    *((double*)buf) = i;
    return get_size_in_bytes(i);
}

inline size_t restore_from_bytes(double& i, const BYTE* buf)
{
    i = *((double*)buf);
    return get_size_in_bytes(i);
};



// ============== PAIR =====================
template <class T>
inline size_t get_size_in_bytes (const pair<T, T>& t)
{
    return get_size_in_bytes(t.first) * 2;
};

template <class T>
inline size_t save_to_bytes(const pair<T, T>& t, BYTE* buf)


{
    buf += save_to_bytes(t.first, buf);
    buf += save_to_bytes(t.second, buf);
    return get_size_in_bytes(t);
};

template <class T>
inline size_t restore_from_bytes(pair<T, T>& t, const BYTE* buf)
{
    buf += restore_from_bytes(t.first, buf);
    buf += restore_from_bytes(t.second, buf);
    return get_size_in_bytes(t);
};

//
// ============== PAIR =====================
template <class T>
inline size_t get_size_in_bytes (const pair<QWORD, T>& t)
{
    return get_size_in_bytes(t.first) + get_size_in_bytes(t.second);
};

template <class T>
inline size_t save_to_bytes(const pair<QWORD, T>& t, BYTE* buf)


{
    buf += save_to_bytes(t.first, buf);
    buf += save_to_bytes(t.second, buf);
    return get_size_in_bytes(t);
};

template <class T>
inline size_t restore_from_bytes(pair<QWORD, T>& t, const BYTE* buf)
{
    buf += restore_from_bytes(t.first, buf);
    buf += restore_from_bytes(t.second, buf);
    return get_size_in_bytes(t);
};


// ============== TRIPLE =====================


template <class T>
inline size_t get_size_in_bytes (const troika<T, T, T>& t)
{
    return get_size_in_bytes(t.first) * 3;
};

template <class T>
inline size_t save_to_bytes(const troika<T, T, T>& t, BYTE* buf)
{
    buf += save_to_bytes(t.first, buf);
    buf += save_to_bytes(t.second, buf);
    buf += save_to_bytes(t.third, buf);
    return get_size_in_bytes(t);
};

template <class T>
inline size_t restore_from_bytes(troika<T, T, T>& t, const BYTE* buf)
{
    buf += restore_from_bytes(t.first, buf);
    buf += restore_from_bytes(t.second, buf);
    buf += restore_from_bytes(t.third, buf);
    return get_size_in_bytes(t);
};


const int VectorMaxStructSize = 200;

template <class T>
bool BinaryReadItem (FILE* fp, T& V)
{
    BYTE buffer[VectorMaxStructSize];
    size_t size_of_t = get_size_in_bytes(V);
    if (fread ((void*)buffer, size_of_t, 1, fp)!=1)
        return false;
    restore_from_bytes (V, buffer);
    return true;
}

template <class T>
void ReadVectorInner (FILE* fp, vector<T>& V, size_t Count)
{
    try
    {
        T dummy;
        size_t size_of_t = get_size_in_bytes(dummy);

        BYTE buffer[VectorMaxStructSize];
        assert (size_of_t < VectorMaxStructSize);

        V.reserve(V.size() + Count);
        if (V.capacity() < Count) 
            throw CExpc(Format("cannot allocate %u bytes in ReadVectorInner",size_of_t*Count));

        for (int i = 0; i < Count; i++)
        {
            if (fread ((void*)buffer, size_of_t, 1, fp)!=1)
                throw CExpc(Format("cannot read %i item in ReadVectorInner",i));
            restore_from_bytes (dummy, buffer);
            V.push_back(dummy);
        };
    }
    catch ( length_error  &e ) 
    {
        fprintf (stderr, "ReadVectorInner:length_error exception is caught: %s\n", e.what( ));
        throw;
    }
    catch ( exception &e ) 
    {
        fprintf (stderr, "ReadVectorInner: general std::exception is caught: %s\n", e.what( ));
        throw;
    };

};

template <class T>
size_t GetSizeInBytes()
{
    T dummy;
    return get_size_in_bytes(dummy);
}

template <class T>
inline void ReadVector (const string& FileName, vector<T>& V)
{
    V.clear();
    file_off_t sz = FileSize(FileName.c_str());

    FILE* fp = fopen (FileName.c_str(),"rb");
    if (!fp) return;
        
    T dummy;
    size_t size_of_t = get_size_in_bytes(dummy);
    size_t Count = (size_t)sz/size_of_t;
    try {
        ReadVectorInner(fp, V, Count);
        fclose (fp);
        fp = 0;
    }
    catch (...)
    {
        if (fp) fclose (fp);
        throw;
    }
        
};


template <class T>
bool BinaryWriteItem (FILE* fp, const T& V)
{
    BYTE buffer[VectorMaxStructSize];
    save_to_bytes(V, buffer);
    size_t size_of_t = get_size_in_bytes(V);
    return fwrite((void*)buffer, size_of_t, 1, fp) == 1;
}

template <class T>
bool WriteVectorInner (FILE* fp, const vector<T>& V)
{
    T dummy;
    size_t size_of_t = get_size_in_bytes(dummy);

    BYTE buffer[VectorMaxStructSize];
    assert (size_of_t < VectorMaxStructSize);

    size_t  count = V.size();

    for (size_t i =0; i < count; i++)
    {
        save_to_bytes(V[i], buffer);
        if (!fwrite((void*)buffer, size_of_t, 1, fp)) return false;
    };
    return true;
};


template <class T>
inline bool WriteVector (const string& FileName, const vector<T>& V)
{
    FILE* fp = fopen (FileName.c_str(),"wb");
    if (!fp)
    {
        ErrorMessage ("Cannot write vector to "+FileName);
        return false;
    };
    bool b = WriteVectorInner(fp, V);
    fclose (fp);
    return b;
};

#endif

/*--- emacs style variables ---
 * Local Variables:
 *  mode: C++
 *  c-file-style: "ellemtel"
 *  c-basic-offset: 4
 *  tab-width: 8
 *  indent-tabs-mode: nil
 * End:
 */