Serializer.h

Go to the documentation of this file.

/***
 * Copyright (c) 2005, SkeTo Project
 * All rights reserved.
 */
#ifndef __SERIALIZER_H__
#define __SERIALIZER_H__

#include<utility>
template <typename A>
class Serializer {
public:
    static unsigned char* construct(A *obj, unsigned char *buf){
        return obj->construct(buf);
    }
    static unsigned char* serialize(const A& obj, unsigned char *buf){
        return obj.serialize(buf);
    }
    static int getSerializedSize(const A& obj){
        return obj.getSerializedSize();
    }
    static bool needsSerializing(){
        return A::needsSerializing(); 
    }
};
template <>
class Serializer<int> {
public:
    static unsigned char* construct(int*obj, unsigned char *buf){
        *obj=*(int*)buf;        
        return buf+sizeof(int);
    }
    static unsigned char* serialize(const int& obj, unsigned char *buf){
        *((int*)buf) = obj;
        return buf+sizeof(int);
    }
    static int getSerializedSize(const int& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};
template <>
class Serializer<unsigned int> {
public:
    static unsigned char* construct(unsigned int *obj, unsigned char *buf){
        *obj=*(unsigned int*)buf;       
        return buf+sizeof(unsigned int);
    }
    static unsigned char* serialize(const unsigned int& obj, unsigned char *buf){
        *((unsigned int*)buf) = obj;
        return buf+sizeof(unsigned int);
    }
    static int getSerializedSize(const unsigned int& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};
template <>
class Serializer<char> {
public:
    static unsigned char* construct(char*obj, unsigned char *buf){
        *obj=*(char*)buf;       
        return buf+sizeof(char);
    }
    static unsigned char* serialize(const char& obj, unsigned char *buf){
        *((char*)buf) = obj;
        return buf+sizeof(char);
    }
    static int getSerializedSize(const char& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};
template <>
class Serializer<unsigned char> {
public:
    static unsigned char* construct(unsigned char* obj, unsigned char *buf){
        *obj=*(unsigned char*)buf;      
        return buf+sizeof(unsigned char);
    }
    static unsigned char* serialize(const unsigned char& obj, unsigned char *buf){
        *((unsigned char*)buf) = obj;
        return buf+sizeof(unsigned char);
    }
    static int getSerializedSize(const unsigned char& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};
template <>
class Serializer<bool> {
public:
    static unsigned char* construct(bool* obj, unsigned char *buf){
        *obj=*(bool*)buf;       
        return buf+sizeof(bool);
    }
    static unsigned char* serialize(const bool& obj, unsigned char *buf){
        *((bool*)buf) = obj;
        return buf+sizeof(bool);
    }
    static int getSerializedSize(const bool& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};

template <>
class Serializer<double> {
public:
    static unsigned char* construct(double* obj, unsigned char *buf){
        *obj=*(double*)buf;     
        return buf+sizeof(double);
    }
    static unsigned char* serialize(const double& obj, unsigned char *buf){
        *((double*)buf) = obj;
        return buf+sizeof(double);
    }
    static int getSerializedSize(const double& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};

template <>
class Serializer<const double> {
public:
    static unsigned char* construct(double* obj, unsigned char *buf){
        *obj=*(double*)buf;     
        return buf+sizeof(double);
    }
    static unsigned char* serialize(const double& obj, unsigned char *buf){
        *((double*)buf) = obj;
        return buf+sizeof(double);
    }
    static int getSerializedSize(const double& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};


template <>
class Serializer<float> {
public:
    static unsigned char* construct(float* obj, unsigned char *buf){
        *obj=*(float*)buf;      
        return buf+sizeof(float);
    }
    static unsigned char* serialize(const float& obj, unsigned char *buf){
        *((float*)buf) = obj;
        return buf+sizeof(float);
    }
    static int getSerializedSize(const float& obj){
        return sizeof(obj);
    }
    static bool needsSerializing(){
        return false; 
    }
};



template <typename A, typename B>
class Serializer<const std::pair<A,B> > {
public:
 public:    
    static unsigned char* construct(std::pair<A,B>* obj, unsigned char *buf){
        buf=Serializer<A>::construct(&obj->first, buf);
        buf=Serializer<B>::construct(&obj->second, buf);
        return buf;
    }
 public:
    static unsigned char* serialize(const std::pair<A,B>& obj, unsigned char *buf){
        buf=Serializer<A>::serialize(obj.first, buf);
        buf=Serializer<B>::serialize(obj.second, buf);
        return buf;
    }
 public:
    static int getSerializedSize(const std::pair<A,B>& obj){
        int size = 0;
        size+=Serializer<A>::getSerializedSize(obj.first);
        size+=Serializer<B>::getSerializedSize(obj.second);
        return size;
    }
    static bool needsSerializing(){
        return true; 
    }
};

template <typename A, typename B>
class Serializer<std::pair<A,B> > {
public:
 public:    
    static unsigned char* construct(std::pair<A,B>* obj, unsigned char *buf){
        buf=Serializer<A>::construct(&obj->first, buf);
        buf=Serializer<B>::construct(&obj->second, buf);
        return buf;
    }
 public:
    static unsigned char* serialize(const std::pair<A,B>& obj, unsigned char *buf){
        buf=Serializer<A>::serialize(obj.first, buf);
        buf=Serializer<B>::serialize(obj.second, buf);
        return buf;
    }
 public:
    static int getSerializedSize(const std::pair<A,B>& obj){
        int size = 0;
        size+=Serializer<A>::getSerializedSize(obj.first);
        size+=Serializer<B>::getSerializedSize(obj.second);
        return size;
    }
    static bool needsSerializing(){
        return true; 
    }
};



#endif // __SERIALIZER_H__

---