bas.hpp

Go to the documentation of this file.

/*
** Byte Array Serialization
** File description:
** Header only lib which purpose is to be able to easily serialize data/classes
** to send them over networking protocol and unserialize them easily afterward.
** Author:
** Nell Fauveau
** https://github.com/Nellousan/ByteArraySerialisation
*/

/* Current Changelogs:
    - BugFix: pushData specialization on the SerializedObject
    - Changed the way serialization works, now the makeSerialization function
    needs override, serialization() is still the way of retrieving the SerializedObject,
    same goes for makeUnserialization and unserialization()
    - SerializedObject doesn't need the size to construct from char * anymore. A Checksum has been added
    to make this possible, and to add possibilities in networking (knowing if multiple objects have been received and such).
    - Moved bodies of pushData(), popData() and popDataArray() to separate function to
    avoid code duplication and make the addition of specialised function template easier.
    - Added documentation of the library, generated by doxygen.
*/

#ifndef BAS_HPP_
#define BAS_HPP_

#include <cstring>
#include <memory>
#include <tuple>
#include <vector>

#include <iostream>


#define _BAS_SIZE_BYTES_ 2 // Number of bytes used to store var size and array size in the payload,
#define _BAS_ARRAY_SIZE_ 2 // MAX is your OS size_t byte size (4 is max recommended as it will be compatible in most cases)
#define _BAS_CHECKSUM_SIZE_ 4 // If this lib is used for networking, make sure that these 3 numbers are the same on both ends


namespace bas {

template <typename T>
class Helper;

template <typename T>
class PoppedArray;

class SerializedObject {
public:
    SerializedObject()
    {
        prepareChecksum();
    }

    inline SerializedObject(const char* data)
    {
        constructFromPayload(data);
    }


    inline SerializedObject(const SerializedObject& other)
        : _data(other._data)
        , _isChecksumRemoved(other._isChecksumRemoved)
    {
    }

    ~SerializedObject() = default;

    template <typename T>
    inline void pushData(const T& data)
    {
        Helper<T> helper;
        helper.pushData(*this, data);
    }

    template <typename T>
    inline void pushData(const T* data, size_t array_size)
    {
        const char* data_ = (const char*)data;
        size_t size = sizeof(T);

        pushSizes(size, array_size);

        pushRawData(size, array_size, data_);

        checksumUpdate();
    }

    template <typename T>
    inline T popData(void)
    {
        Helper<T> helper;
        return helper.popData(*this);
    }

    template <typename T>
    inline PoppedArray<T> popDataArray(void)
    {
        size_t size = 0;
        size_t array_size = 0;
        T* var;

        std::tie(size, array_size) = getSizes();

        var = new T[array_size];

        copyMem(size, array_size, var);

        return PoppedArray<T>(array_size, var);
    }

    inline const char* payload(void) const
    {
        return _data.data();
    }

    inline std::vector<char>& vector(void)
    {
        return _data;
    }

    inline size_t size(void) const
    {
        return _data.size();
    }

    inline void clear()
    {
        _data.clear();
        _isChecksumRemoved = false;
    }

    inline SerializedObject& operator=(const SerializedObject& other)
    {
        _data = other._data;
        _isChecksumRemoved = other._isChecksumRemoved;
        return *this;
    }

    inline SerializedObject& operator=(const char* data)
    {
        constructFromPayload(data);
        return *this;
    }

    inline void removeChecksum(void)
    {
        if (_isChecksumRemoved)
            return;
        _isChecksumRemoved = true;
        for (size_t i = 0; i < _BAS_CHECKSUM_SIZE_; i++)
            _data.erase(_data.begin());
    }

    inline void addChecksum(void)
    {
        if (!_isChecksumRemoved)
            return;
        for (size_t i = 0; i < _BAS_CHECKSUM_SIZE_; i++)
            _data.insert(_data.begin(), 0);
        checksumUpdate();
    }

private:
    inline void prepareChecksum(void)
    {
        for (size_t i = 0; i < _BAS_CHECKSUM_SIZE_; i++)
            _data.push_back(0);
    }

    inline void constructFromPayload(const char* data)
    {
        size_t size = 0;
        for (size_t i = 0; i < _BAS_CHECKSUM_SIZE_; i++) {
            size |= (data[i] << (i * 8));
        }
        _data.assign(data, data + size + _BAS_CHECKSUM_SIZE_);
    }

    inline void checksumUpdate(void)
    {
        size_t size = _data.size();

        if (_isChecksumRemoved)
            addChecksum();

        for (size_t i = 0; i < _BAS_CHECKSUM_SIZE_; i++) {
            _data[i] = (size >> (i * 8));
        }
    }

    inline void pushRawData(size_t size, size_t array_size, const char* data)
    {
        for (size_t j = 0; j < array_size; j++) {
            for (size_t i = 0; i < size; i++) {
                _data.push_back(data[j * size + i]);
            }
        }
    }

    inline void pushSizes(size_t size, size_t array_size)
    {
        for (size_t i = 0; i < _BAS_SIZE_BYTES_; i++)
            _data.push_back((size >> (i * 8)) & 0xFF);

        for (size_t i = 0; i < _BAS_ARRAY_SIZE_; i++)
            _data.push_back((array_size >> (i * 8)) & 0xFF);
    }

    inline std::tuple<int, int> getSizes(void)
    {
        size_t size = 0, array_size = 0;

        if (!_isChecksumRemoved) {
            removeChecksum();
        }

        for (size_t i = 0; i < _BAS_SIZE_BYTES_; i++) {
            size |= (_data.front() << (i * 8));
            _data.erase(_data.begin());
        }

        for (size_t i = 0; i < _BAS_ARRAY_SIZE_; i++) {
            array_size |= (_data.front() << (i * 8));
            _data.erase(_data.begin());
        }
        return std::make_tuple(size, array_size);
    }

    template <typename T>
    inline void copyMem(size_t size, size_t array_size, T* var)
    {
        for (size_t j = 0; j < array_size; j++) {
            std::memcpy(var + j, _data.data(), size);
            for (size_t i = 0; i < size; i++) {
                _data.erase(_data.begin());
            }
        }
    }

    std::vector<char> _data;
    bool _isChecksumRemoved = false;

    template <typename T>
    friend class Helper;
    friend class Helper<std::string>;
};

class Serializable {
public:

    virtual ~Serializable() = default;

    virtual void makeSerialization(SerializedObject& obj) = 0;

    virtual void makeUnserialization(SerializedObject& obj) = 0;

    inline void unserialize(SerializedObject obj)
    {
        makeUnserialization(obj);
    }

    inline SerializedObject serialize(void)
    {
        SerializedObject obj;
        makeSerialization(obj);
        return obj;
    }

private:
};

template <typename T>
class PoppedArray {

public:
    PoppedArray() = default;

    inline PoppedArray(size_t size, T* ptr)
        : _size(size)
        , _ptr(ptr)
    {
    }

    inline size_t size(void)
    {
        return _size;
    }

    inline T* get(void)
    {
        return _ptr.get();
    }

private:
    size_t _size;
    std::shared_ptr<T> _ptr;
};


template <typename T>
class Helper {
public:
    inline void pushData(SerializedObject& obj, const T& data_)
    {
        const char* data = (const char*)&data_;
        size_t size = sizeof(T);
        size_t array_size = 1;

        obj.pushSizes(size, array_size);

        obj.pushRawData(size, array_size, data);

        obj.checksumUpdate();
    }

    inline T popData(SerializedObject& obj)
    {
        size_t size = 0;
        size_t array_size = 0;
        T var;

        std::tie(size, array_size) = obj.getSizes();

        obj.copyMem(size, array_size, &var);

        return var;
    }

};
template <>
class Helper<std::string> {
public:
    inline void pushData(SerializedObject& obj, const std::string& data_)
    {
        const char* data = data_.c_str();
        size_t size = sizeof(char);
        size_t array_size = data_.size() + 1;
        
        obj.pushSizes(size, array_size);

        obj.pushRawData(size, array_size, data);

        obj.checksumUpdate();
    }

    inline std::string popData(SerializedObject &obj)
    {
        size_t size = 0;
        size_t array_size = 0;
        std::string str;
        char* var;

        std::tie(size, array_size) = obj.getSizes();
    
        var = new char[array_size];
    
        obj.copyMem(size, array_size, var);
    
        str = var;
    
        delete var;
    
        return str;
    }

};

template <typename T>
class Helper<std::vector<T>> {
public:
    inline void pushData(SerializedObject& obj, const std::vector<T>& data_)
    {
        const char* data = (char*)data_.data();
        size_t size = sizeof(T);
        size_t array_size = data_.size();
        
        obj.pushSizes(size, array_size);

        obj.pushRawData(size, array_size, data);

        obj.checksumUpdate();
    }

    inline std::vector<T> popData(SerializedObject &obj)
    {
        size_t size = 0;
        size_t array_size = 0;
        std::vector<T> vector;
        T* var;

        std::tie(size, array_size) = obj.getSizes();
    
        var = new T[array_size];
    
        obj.copyMem(size, array_size, var);
    
        vector.assign(var, var + array_size);
    
        delete var;
    
        return vector;
    }

};

template <>
class Helper<SerializedObject> {
public:
    inline void pushData(SerializedObject& obj, SerializedObject& data_)
    {
        const char* data = (char*)data_.payload();
        size_t size = sizeof(char);
        size_t array_size = data_.size();
        
        obj.pushSizes(size, array_size);

        obj.pushRawData(size, array_size, data);

        obj.checksumUpdate();
    }

    inline SerializedObject popData(SerializedObject &obj)
    {
        size_t size = 0;
        size_t array_size = 0;
        SerializedObject obj;
        char* var;

        std::tie(size, array_size) = obj.getSizes();
    
        var = new char[array_size];
    
        obj.copyMem(size, array_size, var);
    
        obj = var;
    
        delete var;
    
        return obj;
    }

};
}

#endif /* !BAS_HPP_ */