SaveGame.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_SAVE_GAME_H
#define HPL_SAVE_GAME_H

#include "hpl1/engine/system/SerializeClass.h"
#include "hpl1/engine/system/SystemTypes.h"
#include "common/stablemap.h"
#include "common/multimap.h"

class TiXmlElement;

#define kSaveData_LoadFromBegin(aClass)                                        \
    super::LoadFromSaveData(apSaveData);                                       \
    cSaveData_##aClass *pData = static_cast<cSaveData_##aClass *>(apSaveData); \
    assert(pData != nullptr);

#define kSaveData_SaveToBegin(aClass)                                          \
    super::SaveToSaveData(apSaveData);                                         \
    cSaveData_##aClass *pData = static_cast<cSaveData_##aClass *>(apSaveData); \
    assert(pData != nullptr);

#define kSaveData_SetupBegin(aClass)                                           \
    super::SaveDataSetup(apSaveObjectHandler, apGame);                         \
    cSaveData_##aClass *pData = static_cast<cSaveData_##aClass *>(mpSaveData); \
    assert(pData != nullptr);

#define kSaveData_BaseClass(aClass) class cSaveData_##aClass : public iSaveData
#define kSaveData_ChildClass(aParent, aChild) class cSaveData_##aChild : public cSaveData_##aParent

#define kSaveData_ClassInit(aClass) kSerializableClassInit(cSaveData_##aClass)

// Helpers to copy data.
#define kSaveData_SaveTo(aVar) pData->aVar = aVar;
#define kSaveData_LoadFrom(aVar) aVar = pData->aVar;

#define kSaveData_SaveObject(aObject, aId)       \
    if (aObject)                                 \
        pData->aId = aObject->GetSaveObjectId(); \
    else                                         \
        pData->aId = -1;

// Only used in setup:
#define kSaveData_LoadObject(aObject, aId, aClass)                           \
    if (pData->aId == -1)                                                    \
        aObject = NULL;                                                      \
    else {                                                                   \
        aObject = static_cast<aClass>(apSaveObjectHandler->Get(pData->aId)); \
    }

// Helpers to copy containers with SaveDataId
#define kSaveData_SaveIdList(aSrcList, aSrcIt, aDestList)            \
    pData->aDestList.Clear();                                        \
    for (aSrcIt it = aSrcList.begin(); it != aSrcList.end(); ++it) { \
        pData->aDestList.Add((*it)->GetSaveObjectId());              \
    }

// Only used in setup:
#define kSaveData_LoadIdList(aSrcList, aDestList, aClass)                \
    {                                                                    \
        cContainerListIterator<int> it = pData->aDestList.GetIterator(); \
        aSrcList.clear();                                                \
        while (it.HasNext()) {                                           \
            int lId = it.Next();                                         \
            iSaveObject *pObject = apSaveObjectHandler->Get(lId);        \
            if (pObject == NULL) {                                       \
                continue;                                                \
            }                                                            \
            aSrcList.push_back(static_cast<aClass>(pObject));            \
        }                                                                \
    }

namespace hpl {

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

class cSaveObjectHandler;
class iSaveObject;
class cGame;

class iSaveData : public iSerializable {
    kSerializableClassInit(iSaveData) public : int mlSaveDataId;

    virtual iSaveObject *CreateSaveObject(cSaveObjectHandler *apSaveObjectHandler, cGame *apGame) = 0;

    virtual int GetSaveCreatePrio() = 0;
};

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

class iSaveObject {
    friend class cSaveObjectHandler;

public:
    iSaveObject();
    virtual ~iSaveObject();

    int GetSaveObjectId() { return mlSaveObjectId; }

    virtual void SaveToSaveData(iSaveData *apSaveData);
    virtual void LoadFromSaveData(iSaveData *apSaveData);

    virtual iSaveData *CreateSaveData() = 0;

    virtual void SaveDataSetup(cSaveObjectHandler *apSaveObjectHandler, cGame *apGame);

    void SetIsSaved(bool abX) { mbIsSaved = abX; }
    bool IsSaved() { return mbIsSaved; }

protected:
    iSaveData *mpSaveData;

private:
    int mlSaveObjectId;
    bool mbIsSaved;
    static int _mlGlobalIdCount;
};

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

typedef Common::MultiMap<int, iSaveObject *> tSaveObjectMap;
typedef tSaveObjectMap::iterator tSaveObjectMapIt;

typedef cSTLMapIterator<iSaveObject *, tSaveObjectMap, tSaveObjectMapIt> cSaveObjectIterator;

class cSaveObjectHandler {
public:
    cSaveObjectHandler();
    ~cSaveObjectHandler();

public:
    void Add(iSaveObject *pObject);

    iSaveObject *Get(int alId);

    cSaveObjectIterator GetIterator();

    void SetUpAll(cGame *apGame);

    void Clear();
    size_t Size();

private:
    tSaveObjectMap m_mapSaveObjects;
};

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

typedef Common::MultiMap<int, iSaveData *> tSaveDataMap;
typedef tSaveDataMap::iterator tSaveDataMapIt;

typedef cSTLMapIterator<iSaveData *, tSaveDataMap, tSaveDataMapIt> cSaveDataIterator;

class cSaveDataHandler : public iContainer {
public:
    cSaveDataHandler();
    ~cSaveDataHandler();

    void Add(iSaveData *pData);

    cSaveDataIterator GetIterator();

    void Clear();
    size_t Size();

private:
    void AddVoidPtr(void **apPtr);
    void AddVoidClass(void *apClass);

    iContainerIterator *CreateIteratorPtr();

    tSaveDataMap m_mapSaveData;
};

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

} // namespace hpl

#endif // HPL_SAVE_GAME_H