SerializeClass.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 * Copyright (C) 2006-2010 - Frictional Games
 *
 * This file is part of HPL1 Engine.
 */

#ifndef HPL_SERIALIZE_CLASS_H
#define HPL_SERIALIZE_CLASS_H

#include "hpl1/engine/system/MemoryManager.h"
#include "hpl1/engine/system/SystemTypes.h"
#include "hpl1/static_string.h"
#include "common/stablemap.h"

class TiXmlElement;

namespace hpl {


typedef unsigned int eSerializeType;

#define eSerializeType_Bool (1)
#define eSerializeType_Int32 (2)
#define eSerializeType_Float32 (3)

#define eSerializeType_String (4)

#define eSerializeType_Vector2l (5)
#define eSerializeType_Vector2f (6)
#define eSerializeType_Vector3l (7)
#define eSerializeType_Vector3f (8)

#define eSerializeType_Matrixf (9)

#define eSerializeType_Color (10)

#define eSerializeType_Rect2l (11)
#define eSerializeType_Rect2f (12)

#define eSerializeType_Planef (13)

#define eSerializeType_WString (14)

#define eSerializeType_Class (100)

// Important with this type is that it will only be created
// if the member variable is NULL. Else it is assume that it is
// already created.
// Also, for the class to be a class pointer it has to have a
// constructor without any parameters.
// NULL Values are NOT allowed!
#define eSerializeType_ClassPointer (101)

// User defined types must be after this
#define eSerializeType_Last (200)

#define eSerializeType_NULL (0xFFFF)


typedef unsigned int eSerializeMainType;

#define eSerializeMainType_Variable (1)
#define eSerializeMainType_Array (2)
#define eSerializeMainType_Container (3)

#define eSerializeMainType_NULL (0xFFFF)


#define ClassMemberOffset(aClass, aMember) (size_t(&(((aClass *)1)->aMember)) - 1)
#define ClassMemberSize(aClass, aMember) (sizeof(((aClass *)1)->aMember))

#define kSerializableClassInit(aClass)                      \
public:                                                     \
    const static char *msSerialize_Name;                    \
    const static char *msSerialize_ParentName;              \
    static cSerializeMemberField *mpSerialize_MemberFields; \
    virtual ~aClass() = default;                            \
    virtual tString Serialize_GetTopClass() { return #aClass; }

#define kSerializableClassInit_nodestructor(aClass)         \
public:                                                     \
    const static char *msSerialize_Name;                    \
    const static char *msSerialize_ParentName;              \
    static cSerializeMemberField *mpSerialize_MemberFields; \
    virtual tString Serialize_GetTopClass() { return #aClass; }

#define kBeginSerialize(aClass, aParent)                                                                       \
    namespace SerializeNamespace_##aClass {                                                                    \
        extern cSerializeMemberField mvTempMemberFields[];                                                     \
    }                                                                                                          \
    const char *aClass::msSerialize_Name = #aClass;                                                            \
    const char *aClass::msSerialize_ParentName = #aParent;                                                     \
    cSerializeMemberField *aClass::mpSerialize_MemberFields = SerializeNamespace_##aClass::mvTempMemberFields; \
    namespace SerializeNamespace_##aClass {                                                                    \
        typedef aClass tVarClass;                                                                              \
        cSerializeMemberField mvTempMemberFields[] = {

#define kBeginSerializeBase(aClass)                                                                            \
    namespace SerializeNamespace_##aClass {                                                                    \
        extern cSerializeMemberField mvTempMemberFields[];                                                     \
    }                                                                                                          \
    const char *aClass::msSerialize_Name = #aClass;                                                            \
    const char *aClass::msSerialize_ParentName = "";                                                           \
    cSerializeMemberField *aClass::mpSerialize_MemberFields = SerializeNamespace_##aClass::mvTempMemberFields; \
    namespace SerializeNamespace_##aClass {                                                                    \
        typedef aClass tVarClass;                                                                              \
        cSerializeMemberField mvTempMemberFields[] = {

#define kBeginSerializeVirtual(aClass, aParent)                                                                \
    namespace SerializeNamespace_##aClass {                                                                    \
        extern cSerializeMemberField mvTempMemberFields[];                                                     \
    }                                                                                                          \
    const char *aClass::msSerialize_Name = #aClass;                                                            \
    const char *aClass::msSerialize_ParentName = #aParent;                                                     \
    cSerializeMemberField *aClass::mpSerialize_MemberFields = SerializeNamespace_##aClass::mvTempMemberFields; \
    namespace SerializeNamespace_##aClass {                                                                    \
        typedef aClass tVarClass;                                                                              \
        cSerializeMemberField mvTempMemberFields[] = {

#define kBeginSerializeBaseVirtual(aClass)                                                                     \
    namespace SerializeNamespace_##aClass {                                                                    \
        extern cSerializeMemberField mvTempMemberFields[];                                                     \
    }                                                                                                          \
    const char *aClass::msSerialize_Name = #aClass;                                                            \
    const char *aClass::msSerialize_ParentName = "";                                                           \
    cSerializeMemberField *aClass::mpSerialize_MemberFields = SerializeNamespace_##aClass::mvTempMemberFields; \
    namespace SerializeNamespace_##aClass {                                                                    \
        typedef aClass tVarClass;                                                                              \
        cSerializeMemberField mvTempMemberFields[] = {

#define kEndSerialize()                                     \
    cSerializeMemberField("", 0, 0, eSerializeType_NULL, 0) \
    }                                                       \
    ;                                                       \
    }

#define kSerializeVar(aVar, aType) \
    cSerializeMemberField(#aVar, ClassMemberOffset(tVarClass, aVar), ClassMemberSize(tVarClass, aVar), aType, eSerializeMainType_Variable),

#define kSerializeVarArray(aVar, aType, aArraySize) \
    cSerializeMemberField(#aVar, ClassMemberOffset(tVarClass, aVar), ClassMemberSize(tVarClass, aVar), aType, eSerializeMainType_Array, aArraySize),

#define kSerializeVarContainer(aVar, aType) \
    cSerializeMemberField(#aVar, ClassMemberOffset(tVarClass, aVar), ClassMemberSize(tVarClass, aVar), aType, eSerializeMainType_Container),

#define kSerializeClassContainer(aVar, aClass, aType) \
    cSerializeMemberField(#aVar, ClassMemberOffset(tVarClass, aVar), ClassMemberSize(tVarClass, aVar), aType, eSerializeMainType_Container, #aClass),


//-------------------------------------------------

class cSerializeMemberField {
public:
    constexpr cSerializeMemberField(Hpl1::StaticString asName, size_t alOffset, size_t alSize, eSerializeType alType,
                                    eSerializeMainType aMainType) : msName(asName), msClassName(""), mlOffset(alOffset), mlSize(alSize), mType(alType), mMainType(aMainType), mlArraySize(0) {
    }

    constexpr cSerializeMemberField(Hpl1::StaticString asName, size_t alOffset, size_t alSize, eSerializeType alType,
                                    eSerializeMainType aMainType, size_t alArraySize) : msName(asName), msClassName(""), mlOffset(alOffset), mlSize(alSize), mType(alType), mMainType(aMainType), mlArraySize(alArraySize) {
    }

    constexpr cSerializeMemberField(Hpl1::StaticString asName, size_t alOffset, size_t alSize, eSerializeType alType,
                                    eSerializeMainType aMainType, Hpl1::StaticString asClassName) : msName(asName), msClassName(asClassName), mlOffset(alOffset), mlSize(alSize), mType(alType), mMainType(aMainType), mlArraySize(0) {
    }

    Hpl1::StaticString msName;
    Hpl1::StaticString msClassName;
    size_t mlOffset;
    size_t mlSize;
    eSerializeType mType;
    eSerializeMainType mMainType;
    size_t mlArraySize;
};

//-------------------------------------------------

class iSerializable {
public:
    virtual ~iSerializable() = default;
    virtual tString Serialize_GetTopClass() { return ""; }
};

//-------------------------------------------------

class iSerializableType {
public:
    virtual ~iSerializableType() = default;
    virtual char *ValueToString(void *apVal) = 0;
    virtual void ValueFromString(char *apString, void *apVal) = 0;
};

//-------------------------------------------------

struct cSerializeSavedClass {
public:
    constexpr cSerializeSavedClass() = default;
    constexpr cSerializeSavedClass(const char *asName, const char *asParent,
                                   cSerializeMemberField *apMemberFields, size_t alSize,
                                   iSerializable *(*apCreateFunc)()) : msName(asName), msParentName(asParent), mpMemberFields(apMemberFields),
                                                                       mlSize(alSize), mpCreateFunc(apCreateFunc) {}

    const char *msName = "";
    const char *msParentName = "";
    cSerializeMemberField *mpMemberFields = nullptr;
    size_t mlSize = 0;
    iSerializable *(*mpCreateFunc)() = nullptr;
};

//-------------------------------------------------

class cSerializeMemberFieldIterator {
public:
    cSerializeMemberFieldIterator(cSerializeSavedClass *apTopClass);

    bool HasNext();
    cSerializeMemberField *GetNext();

private:
    cSerializeSavedClass *mpSavedClass;
    int mlFieldNum;
};

//-------------------------------------------------

typedef Common::StableMap<Hpl1::StaticString, cSerializeSavedClass> tSerializeSavedClassMap;
typedef tSerializeSavedClassMap::iterator tSerializeSavedClassMapIt;

typedef Common::List<cSerializeSavedClass *> tSerializeSavedClassList;
typedef tSerializeSavedClassList::iterator tSerializeSavedClassListIt;

class cSerializeClass {
public:
    static void initSaveClassesMap();
    static void finalizeSaveClassesMap();

    static void SetLog(bool abX);
    static bool GetLog();

    static void PrintMembers(iSerializable *apData);

    static bool SaveToFile(iSerializable *apData, const tWString &asFile, const tString &asRoot);
    static void SaveToElement(iSerializable *apData, const tString &asName, TiXmlElement *apParent, bool abIsPointer = false);

    static bool LoadFromFile(iSerializable *apData, const tWString &asFile);
    static void LoadFromElement(iSerializable *apData, TiXmlElement *apElement, bool abIsPointer = false);

    static cSerializeSavedClass *GetClass(const tString &asName);

    static cSerializeMemberFieldIterator GetMemberFieldIterator(iSerializable *apData);

    static tString ValueToString(void *apData, size_t alOffset, eSerializeType aType);
    static void StringToValue(void *apData, size_t alOffset, eSerializeType aType,
                              const char *asVal);

private:
    static void SaveVariable(TiXmlElement *apElement, cSerializeMemberField *apField, iSerializable *apData);
    static void SaveArray(TiXmlElement *apElement, cSerializeMemberField *apField, iSerializable *apData);
    static void SaveContainer(TiXmlElement *apElement, cSerializeMemberField *apField, iSerializable *apData);

    static void LoadVariable(TiXmlElement *apElement, iSerializable *apData, cSerializeSavedClass *apClass);
    static void LoadArray(TiXmlElement *apElement, iSerializable *apData, cSerializeSavedClass *apClass);
    static void LoadClass(TiXmlElement *apElement, iSerializable *apData, cSerializeSavedClass *apClass);
    static void LoadClassPointer(TiXmlElement *apElement, iSerializable *apData, cSerializeSavedClass *apClass);
    static void LoadContainer(TiXmlElement *apElement, iSerializable *apData, cSerializeSavedClass *apClass);

    static void FillSaveClassMembersList(tSerializeSavedClassList *apList, cSerializeSavedClass *apClass);
    static void SaveSavedClassMembers(cSerializeSavedClass *apClass, iSerializable *apData);

    static cSerializeMemberField *GetMemberField(const tString &asName, cSerializeSavedClass *apClass);

    static size_t SizeOfType(eSerializeType aType);

    static void SetUpData();

    static char msTempCharArray[2048];

    static bool mbDataSetup;
    static tSerializeSavedClassMap *m_mapSavedClasses;
    static Common::Array<iSerializableType *> mvValueTypes;
};

//-------------------------------------------------

}
#endif // HPL_SERIALIZE_CLASS_H