serialize-helpers.hpp

Go to the documentation of this file.

 
#ifndef SERIALIZE_HELPERS_H
#define SERIALIZE_HELPERS_H
 
#include <string.h>
 
#include <utility>
#include <vector>
#include <algorithm>
 
#include "decimal.hpp"
 
namespace lost {
 
class SerializeContext {
public:
    SerializeContext(bool swapIntegerEndianness, bool swapDecimalEndianness)
        : swapIntegerEndianness(swapIntegerEndianness), swapDecimalEndianness(swapDecimalEndianness) { }
    SerializeContext() : SerializeContext(false, false) { }
 
    bool swapIntegerEndianness;
    bool swapDecimalEndianness;
    std::vector<unsigned char> buffer;
};
 
class DeserializeContext {
public:
    explicit DeserializeContext(const unsigned char *buffer) : buffer(buffer), cursor(buffer) { }
 
    size_t GetOffset() const {
        return cursor - buffer;
    }
 
    void MoveForward(size_t howMuch) {
        cursor += howMuch;
    }
 
    const unsigned char *GetCursor() {
        return cursor;
    }
 
private:
    const unsigned char *buffer; 
    const unsigned char *cursor; 
};
 
template <typename T>
void SwapEndianness(unsigned char *buffer) {
    for (int i = 0; i < (int)(sizeof(T)/2); i++) {
        std::swap(buffer[i], buffer[sizeof(T)-1-i]);
    }
}
 
template <typename T>
void SwapEndiannessIfNecessary(unsigned char *buffer, SerializeContext *ser) {
    if (ser->swapIntegerEndianness) {
        SwapEndianness<T>(buffer);
    }
}
 
// template specializations
 
template <>
inline void SwapEndiannessIfNecessary<decimal>(unsigned char *buffer, SerializeContext *ser) {
    if (ser->swapDecimalEndianness) {
        SwapEndianness<decimal>(buffer);
    }
}
 
template <typename T>
void DeserializePadding(DeserializeContext *des) {
    des->MoveForward((sizeof(T) - des->GetOffset()%sizeof(T))%sizeof(T));
}
 
template <typename T>
T DeserializePrimitive(DeserializeContext *des) {
    DeserializePadding<T>(des);
    const T *result = (T *)des->GetCursor(); // endianness should have been taken care of during serialization
    des->MoveForward(sizeof(T));
    return *result;
}
 
template <typename T>
const T *DeserializeArray(DeserializeContext *des, long arrLength) {
    DeserializePadding<T>(des); // Perhaps we should always 8-align arrays? Does that possibly make
                                // any offset calculation or accesses faster?
    const T *result = (T *)des->GetCursor();
    des->MoveForward(sizeof(T)*arrLength);
    return result;
}
 
template <typename T>
void SerializePadding(SerializeContext *ser) {
    for (int i = ser->buffer.size(); i%sizeof(T) != 0; i++) {
        ser->buffer.push_back(0);
    }
}
 
template <typename T>
void SerializePrimitive(SerializeContext *ser, const T &val) {
    unsigned char buf[sizeof(T)];
    memcpy(&buf, &val, sizeof(T));
    SwapEndiannessIfNecessary<T>(buf, ser);
    SerializePadding<T>(ser);
    std::copy(buf, buf+sizeof(T), std::back_inserter(ser->buffer));
}
 
}
 
#endif