青青草原综合久久大伊人导航_色综合久久天天综合_日日噜噜夜夜狠狠久久丁香五月_热久久这里只有精品

class SerializableObject;

class UnserializerBase{
protected:
    UnserializerBase(){}
public:
    virtual ~UnserializerBase(){}

public:
    virtual SerializableObject* Unserialize(const char*& pData) = 0;
};

template<typename T>
class Unserializer : public UnserializerBase{
public:
    typedef T Object;

public:
    Unserializer(){}

public:
    SerializableObject* Unserialize(const char*& pData)
    {
        Object* pObj = new Object; // 要求需要序列化支持的類具有默認(rèn)構(gòu)造函數(shù)
        pData += pObj->Unserialize(pData);
        return pObj;
    }
};

template<typename Object>
static ClassIDType BuildClassID()
{
    static Unserializer<Object> unserializer;
    static std::string name(typeid(Object).name());
    static ClassIDType id = std::hash<BinaryData>()(BinaryData(name.c_str(), name.length()));
    GetIDMapSerializer()[id] = &unserializer;
    return id;
}



static std::map<ClassIDType, UnserializerBase*>& GetIDMapSerializer()
{
    static std::map<ClassIDType, UnserializerBase*> id_unserializer;
    return id_unserializer;
}

// 派生類將自身類型傳遞給模板參數(shù)
template<typename T>
class Serializable : public SerializableObject{
protected:
    static const ClassIDType ID;

public:
    typedef T Object;

protected:
    Serializable(){ID;}

public:
    virtual ~Serializable(){}

public:
    template<typename BufferType>
    void Serialize(BufferType& buffer)
    {
        SaveToBuffer(ID, buffer);
        // 這里應(yīng)該判斷子類序列化是否成功，如果不成功則回滾，暫時未加此功能
            
        static_cast<Object*>(this)->DoSerialize_(buffer);
    }
    size_t Unserialize(const char* pData)
    {
        return DoUnserialize_(pData);
    }
    static const ClassIDType GetClassID(){return ID;}

private:
    // 通過模板模擬虛函數(shù)
    template<typename BufferType>
    void DoSerialize_(BufferType& buffer){};
    virtual size_t DoUnserialize_(const char* pData) = 0;
};

template<typename T>
const typename Serializable<T>::ClassIDType Serializable<T>::ID = Serializable<T>::BuildClassID<T>();

// 此類實(shí)現(xiàn)的靜態(tài)方法Create用于反序列化
class SerializableObject{
public:
    typedef size_t ClassIDType;

protected:
    SerializableObject(){}

public:
    virtual ~SerializableObject(){}

public:
    static SerializableObject* Create(const char*& pData)
    {
        ClassIDType id = 0;
        pData += LoadFromData(id, pData);
        std::map<ClassIDType, UnserializerBase*>& id_serializer = GetIDMapSerializer();
        auto iter = id_serializer.find(id);
        if (id_serializer.end() != iter)
        {
            return (*iter).second->Unserialize(pData);
        }
        return 0;
    }

protected:
    template<typename Object>
    static ClassIDType BuildClassID()
    {
        static Unserializer<Object> unserializer;
        static std::string name(typeid(Object).name());
        static ClassIDType id = std::hash<BinaryData>()(BinaryData(name.c_str(), name.length()));
        GetIDMapSerializer()[id] = &unserializer;
        return id;
    }

private:
    static std::map<ClassIDType, UnserializerBase*>& GetIDMapSerializer()
    {
        static std::map<ClassIDType, UnserializerBase*> id_unserializer;
        return id_unserializer;
    }
};

class Test 
    : public Serializable<Test>
{
    int num_;

public:
    explicit Test(int n = 0) : num_(n){}

private:
    friend class Serializable<Test>;
    template<typename BufferType>
    void DoSerialize_(BufferType& buffer)
    {
        SaveToBuffer(num_, buffer);
    }

    size_t DoUnserialize_(const char* pData)
    {
        return LoadFromData(num_, pData);
    }
};