aleajactaest/khanat-opennel-code
1
0
Fork 0
mirror of https://port.numenaute.org/aleajactaest/khanat-opennel-code.git synced 2024-12-22 08:58:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions
khanat-opennel-code/code/ryzom/common/src/game_share/persistent_data_template.h

610 lines
25 KiB
C
Raw Normal View History

initial version
2010-05-06 00:08:41 +00:00
// Ryzom - MMORPG Framework <http://dev.ryzom.com/projects/ryzom/>
// Copyright (C) 2010 Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero 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 Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
/*
**************************************
NOTE: THIS IS NOT A NORMAL HEADER FILE
**************************************
This header file generates code for the following methods for a user-defined class
void <user_class>::store(CPersistentDataRecord &pdr) const;
void <user_class>::apply(CPersistentDataRecord &pdr);
Note:
Prototypes for these methods are also defined in the DECLARE_PERSISTENCE_METHODS macro in the persistent_data.h file.
Note:
This header may be included several times in the same cpp file in order to instantiate
store and apply methods for different classes
USAGE:
#define PERSISTENT_CLASS <class_name>
#define PERSISTENT_DATA <data_list>
#include "persistent_data_template.h"
#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA
EXAMPLE USAGE:
////////////////////////////////////////////////////////
#define PERSISTENT_CLASS CMyClass
#define PERSISTENT_DATA\
PROP(sint16, Title, getTitle(), setTitle(val))\
PROP(uint64, VisualPropertyA, getVisualPropertyA(), setVisualPropertyA(val))
#include "perstent_data_template.h"
#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA
////////////////////////////////////////////////////////
#define PERSISTENT_CLASS CAnotherClass
#define PERSISTENT_DATA\
PROP_VECT(ucstring,IsIgnoredBy,_IsIgnoredBy,_IsIgnoredBy[i],_IsIgnoredBy[i]=val)\
PROP_MAP(SP_TYPE,uint32,SkillPoints,_SpType,toString(key),val,setSp(fromString(key),val))\
STRUCT(EntityBase,CEntityBaseCharacter::store(pdr),CEntityBaseCharacter::apply(pdr))\
STRUCT_VECT(Pact,_Pact,_Pact[i].store(pdr),_Pact[i].apply(pdr))\
STRUCT_MAP(TAIAlias,TMissionHistory,MissionHistories,_MissionHistories,key,val.store(pdr),_MissionHistories[key].apply(pdr))
#include "persistent_data_template.h"
#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA
////////////////////////////////////////////////////////
MACROS FOR PERSISTENT_DATA DEFINITION
PROP(type,varName)
PROP2(name,type,get,set)
PROP3(name,type,logic,get,set)
PROP_SET(type,varName)
PROP_VECT(type,varName)
PROP_MAP(keyType,valType,varName)
PROP_MAP2(name,keyType,valType,logic,getKey,getVal,set)
STRUCT(varName)
STRUCT2(name,write,read)
STRUCT3(name,logic,write,read)
STRUCT_VECT(varName)
STRUCT_MAP(keyType,valType,varName)
STRUCT_PTR_VECT(type,varName)
STRUCT_MAP2(name,keyType,logic,getKey,valWrite,read)
Where:
name - the name stored in the persistent data record for this data element
varName - the name of a container (map or vector) to be iterated over
type - the data type of a variable
keyType - the data type of the key for a persistent map
valType - the data type of the value for a persistent map
get - code that returns a value to be stored in the persistent data
write - code to be executed for a structure at write time (equivalent to 'get' for a property)
getKey - code that returns a value for a map key to be stored in the persistent data
getVal - code that returns a value for a map value to be stored in the persistent data
valWrite - code to be executed for a map value structure at write time (equivalent to 'getVal' for a property)
set - code to store the value 'val' in persistent property at read time
read - code to be executed for a structure at read time (equivalent to 'get')
Context notes:
write - 'pdr' contains the persistent data record currently being processed
getKey - 'it' is the map iterator
getVal - 'it' is the map iterator
valWrite - 'pdr' contains the persistent data record currently being processed
set - 'val' contains the value to apply
read - 'pdr' contains the persistent data record currently being processed
read - for maps: 'key' contains the map key
read - for property maps: 'val' contains the map entry value
PROP_VECT - 'i' is the vector index during all read and write operations
STRUCT_VECT - 'i' is the vector index during all read and write operations
*/
#ifndef PERSISTENT_CLASS
#error PERSISTENT_CLASS not defined
#endif
#ifndef PERSISTENT_DATA
#error PERSISTENT_DATA not defined
#endif
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#define MAP_LOGIC(keyType,valType,varName) for(std::map<keyType,valType>::const_iterator it=varName.begin();it!=varName.end();++it)
#define SET_LOGIC(type,varName) for(std::set<type>::const_iterator it=varName.begin();it!=varName.end();++it)
#define LIST_LOGIC(type,varName) for(std::list<type>::const_iterator it=varName.begin();it!=varName.end();++it)
#define VECT_LOGIC(varName) ARRAY_LOGIC(varName.size())
#define ARRAY_LOGIC(size) for(uint32 i=0;i<size;++i)
#define DEFAULT_LOGIC {}
#define PROP(type,varName) _PROP(__Tok##varName,#varName,type,DEFAULT_LOGIC,varName,varName=val)
#define NPROP(name,type,varName) _PROP(__Tok##name,#name,type,DEFAULT_LOGIC,varName,varName=val)
#define PROP2(name,type,get,set) _PROP(__Tok##name,#name,type,DEFAULT_LOGIC,get,set)
#define LPROP(type,varName,logic) _PROP(__Tok##varName,#varName,type,logic,varName,varName=val)
#define LPROP2(name,type,logic,get,set) _PROP(__Tok##name,#name,type,logic,get,set)
#define PROP_SET(type,varName) _PROP(__Tok##varName,#varName,type,SET_LOGIC(type,varName),(*it),varName.insert(val))
#define PROP_LIST(type,varName) _PROP(__Tok##varName,#varName,type,LIST_LOGIC(type,varName),(*it),varName.push_back(val))
#define PROP_VECT(type,varName) _PROP(__Tok##varName,#varName,type,VECT_LOGIC(varName),varName[i],varName.push_back(val))
#define LPROP_VECT(type,varName,logic) _PROP(__Tok##varName,#varName,type,logic,varName[i],varName.push_back(val))
#define LPROP_VECT2(name,type,logic,get,set) _PROP(__Tok##name,#name,type,logic,get,set)
#define PROP_MAP(keyType,valType,varName) _PROP_MAP(__Tok##varName,#varName,keyType,valType,MAP_LOGIC(keyType,valType,varName),it->first,it->second,varName[key]=val)
#define NPROP_MAP(name,keyType,valType,varName) _PROP_MAP(__Tok##name,#name,keyType,valType,MAP_LOGIC(keyType,valType,varName),it->first,it->second,varName[key]=val)
#define PROP_MAP2(name,keyType,valType,getKey,getVal,set) _PROP_MAP(__Tok##name,#name,keyType,valType,MAP_LOGIC(keyType,valType,varName),getKey,getVal,set)
#define PROP_ARRAY(type,varName,size) _PROP_MAP(__Tok##varName,#varName,uint32,type,ARRAY_LOGIC(size),i,varName[i],if (key<size) varName[key]=val)
#define LPROP_MAP2(name,keyType,valType,logic,getKey,getVal,set) _PROP_MAP(__Tok##name,#name,keyType,valType,logic,getKey,getVal,set)
#define STRUCT(varName) _STRUCT(__Tok##varName,#varName,DEFAULT_LOGIC,(varName).store(pdr),(varName).apply(pdr))
#define STRUCT2(name,write,read) _STRUCT(__Tok##name,#name,DEFAULT_LOGIC,write,read)
#define LSTRUCT(varName,logic) _STRUCT(__Tok##varName,#varName,logic,(varName).store(pdr),(varName).apply(pdr))
#define LSTRUCT2(name,logic,write,read) _STRUCT(__Tok##name,#name,logic,write,read)
#define STRUCT_LIST(type,varName) _STRUCT(__Tok##varName,#varName,LIST_LOGIC(type,varName),(*it).store(pdr),listAppend(varName).apply(pdr))
#define STRUCT_VECT(varName) _STRUCT(__Tok##varName,#varName,VECT_LOGIC(varName),varName[i].store(pdr),vectAppend(varName).apply(pdr))
#define LSTRUCT_VECT(varName,logic,write,read) _STRUCT(__Tok##varName,#varName,logic,write,read)
#define STRUCT_PTR_VECT(type,varName) _STRUCT(__Tok##varName,#varName,VECT_LOGIC(varName),if (varName[i]!=NULL)varName[i]->store(pdr),(varName.push_back(new type),varName.back())->apply(pdr))
#define STRUCT_SMRTPTR_VECT(type,varName) _STRUCT(__Tok##varName,#varName,VECT_LOGIC(varName),if (varName[i]!=NULL)varName[i]->store(pdr),(varName.push_back(NLMISC::CSmartPtr<type>(new type)),varName.back())->apply(pdr))
#define STRUCT_INDEXED_VECT(varName) _STRUCT_MAP(__Tok##varName,#varName,uint32,VECT_LOGIC(varName),i,varName[i].store(pdr),if (key>=varName.size()) varName.resize(key); varName[key].apply(pdr))
#define STRUCT_MAP(keyType,valType,varName) _STRUCT_MAP(__Tok##varName,#varName,keyType,MAP_LOGIC(keyType,valType,varName),it->first,it->second.store(pdr),varName[key].apply(pdr))
#define LSTRUCT_MAP2(name,keyType,logic,getKey,valWrite,read) _STRUCT_MAP(__Tok##name,#name,keyType,logic,getKey,valWrite,read)
#define STRUCT_ARRAY(varName,size) _STRUCT_MAP(__Tok##varName,#varName,uint32,ARRAY_LOGIC(size),i,varName[i].store(pdr),if (key<size) varName[key].apply(pdr))
#define FLAG(name,applyCode) _FLAG(__Tok##name,#name,DEFAULT_LOGIC,applyCode)
#define FLAG0(name,applyCode) _FLAG(__Tok##name,#name,if(false),applyCode)
#define LFLAG(name,logic,applyCode) _FLAG(__Tok##name,#name,logic,applyCode)
#ifndef PERSISTENT_GAME_CYCLE_INLINE_DEFINED
#define PERSISTENT_GAME_CYCLE_INLINE_DEFINED
#include "tick_event_handler.h"
#include "nel/misc/hierarchical_timer.h"
inline uint32 saveGameCycleToSecond(NLMISC::TGameCycle tick)
{
// Evaluate the UTC of this event (with the current date of save). Suppose that 1 second==10 tick
return sint32(NLMISC::CTime::getSecondsSince1970()) + (sint32(tick) - sint32(CTickEventHandler::getGameCycle()))/10;
// NB: result should be positive since no event should have been launched before 1970!
}
inline NLMISC::TGameCycle loadSecondToGameCycle(uint32 second)
{
// Convert UTC of the event to game cycle. Suppose that 1 second==10 tick
sint32 newTick= CTickEventHandler::getGameCycle() + (sint32(second) - sint32(NLMISC::CTime::getSecondsSince1970()))*10;
// If game cycle is loaded on a server where current game cycle is too young, we can have here negative values => avoid them
return std::max(newTick, sint32(0));
}
#endif
// GameCycle property (saved as a UTC of the current game cycle, support server migration)
#define PROP_GAME_CYCLE(varName)\
/* read and write, in UTC seconds. if result is negative, clamp to 0 */ \
PROP2(UTC_##varName, uint32, saveGameCycleToSecond(varName), varName=loadSecondToGameCycle(val))
// GameCycle property with Backward compatibility (saved as a UTC of the current game cycle, support server migration)
#define PROP_GAME_CYCLE_COMP(varName)\
/* don't write (old variable name), but direct read if in pdr */ \
LPROP2(varName, NLMISC::TGameCycle, if(0), 0, varName=val) \
/* read and write, in UTC seconds. if result is negative, clamp to 0 */ \
PROP2(UTC_##varName, uint32, saveGameCycleToSecond(varName), varName=loadSecondToGameCycle(val))
// SideNotes:
// if the server where we load the game cycle is different from the one from where we saved, and if he is younger,
// then we can have situations where gamecycle<0. Since TGameCycle is actually a uint32, this will cause bugs.
// Hence we don't allow <0 values.
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////////////////
//
// NOTE: This method is declared in DECLARE_PERSISTENCE_METHODS macro in persistent_data.h
//
///////////////////////////////////////////////////////////////////////////////////////////
#ifndef PERSISTENT_NO_STORE
#ifdef PERSISTENT_TOKEN_FAMILY
#ifdef NL_OS_WINDOWS
#pragma message( "Using token family "NL_MACRO_TO_STR(PERSISTENT_TOKEN_FAMILY)" for persistent data class " NL_MACRO_TO_STR(PERSISTENT_CLASS) )
#endif // NL_OS_WINDOWS
// setup some macros for constructing the classname and object name that we need for
// the 'persistent token family' constants class
#define _EVAL(b,c) b##c
#define _BUILD_TOKENS_CLASSNAME(c) _EVAL(c,__constants__class)
#define _BUILD_TOKENS_OBJNAME(c) _EVAL(c,__constants__obj)
// setup the class name and object name for the 'persistent token family' constants class and its instance
#ifdef PERSISTENT_TOKEN_CLASS
#define _TOKENS_CLASSNAME _BUILD_TOKENS_CLASSNAME(PERSISTENT_TOKEN_CLASS)
#define _TOKENS_OBJNAME _BUILD_TOKENS_OBJNAME(PERSISTENT_TOKEN_CLASS)
#else
#define _TOKENS_CLASSNAME _BUILD_TOKENS_CLASSNAME(PERSISTENT_CLASS)
#define _TOKENS_OBJNAME _BUILD_TOKENS_OBJNAME(PERSISTENT_CLASS)
#endif
// define the set of tokens required by this class
// adding them to some pre-defined token family
struct _TOKENS_CLASSNAME
{
// the ctor is used to setup the values of the static tokens
_TOKENS_CLASSNAME()
{
#define _ADD_TOKEN(token) CPdrTokenRegistry::getInstance()->addToken(NL_MACRO_TO_STR(PERSISTENT_TOKEN_FAMILY),token)
__Tok__MapKey= _ADD_TOKEN("__Key__");
__Tok__MapVal= _ADD_TOKEN("__Val__");
#define _PROP(token,name,type,logic,get,set) token= _ADD_TOKEN(name);
#define _STRUCT(token,name,logic,write,read) token= _ADD_TOKEN(name);
#define _PROP_MAP(token,name,keyType,valType,logic,getKey,getVal,set) token= _ADD_TOKEN(name);
#define _STRUCT_MAP(token,name,keyType,logic,getKey,valWrite,read) token= _ADD_TOKEN(name);
#define _FLAG(token,name,logic,code) token= _ADD_TOKEN(name);
PERSISTENT_DATA
#undef _PROP
#undef _STRUCT
#undef _PROP_MAP
#undef _STRUCT_MAP
#undef _FLAG
#undef _ADD_TOKEN
}
// define the set of static variables to act as constants for stocking the set of tokens for this persistet data class
uint16 __Tok__MapKey;
uint16 __Tok__MapVal;
#define _PROP(token,name,type,logic,get,set) uint16 token;
#define _STRUCT(token,name,logic,write,read) uint16 token;
#define _PROP_MAP(token,name,keyType,valType,logic,getKey,getVal,set) uint16 token;
#define _STRUCT_MAP(token,name,keyType,logic,getKey,valWrite,read) uint16 token;
#define _FLAG(token,name,logic,code) uint16 token;
PERSISTENT_DATA
#undef _PROP
#undef _STRUCT
#undef _PROP_MAP
#undef _STRUCT_MAP
#undef _FLAG
};
static _TOKENS_CLASSNAME _TOKENS_OBJNAME;
#undef _TOKENS_CLASSNAME
#undef _TOKENS_OBJNAME
#else
#pragma message( " ")
#pragma message( "NON-OPTIMISED: Persistent data class " NL_MACRO_TO_STR(PERSISTENT_CLASS) " not using a token family")
#pragma message( " ")
#endif
// define _PERSISTENT_STORE_ARGS as either (<empty>) or (","<extra args>) for use in adding args to the store() function prototype
#ifdef PERSISTENT_STORE_ARGS
#define _PERSISTENT_STORE_ARGS ,PERSISTENT_STORE_ARGS
#else
#define _PERSISTENT_STORE_ARGS
#endif
// store()
void PERSISTENT_CLASS::store(CPersistentDataRecord &pdr _PERSISTENT_STORE_ARGS) const
{
// PDR debug helper
#ifdef NL_DEBUG
//nldebug("PDR:store:"NL_MACRO_TO_STR(PERSISTENT_CLASS)"(enter)");
# define _PDR_TRACE(name) //nldebug("PDR:store:" NL_MACRO_TO_STR(PERSISTENT_CLASS) "." #name)
#else
# define _PDR_TRACE(name)
#endif
#ifdef PERSISTENT_TOKEN_FAMILY
#ifdef NL_DEBUG
// this class has been configured to use a specific token family. This means that it is not possible
// to store the class to a pdr that is not using the same token family.
BOMB_IF(pdr.getTokenFamily()!=NL_MACRO_TO_STR(PERSISTENT_TOKEN_FAMILY),
NL_MACRO_TO_STR(PERSISTENT_CLASS)"::store() requires token family '"NL_MACRO_TO_STR(PERSISTENT_TOKEN_FAMILY)"'"
" but pdr is using token family '"+pdr.getTokenFamily()+"'",
return);
#endif
#ifdef PERSISTENT_TOKEN_CLASS
#define _TOKEN(token) _BUILD_TOKENS_OBJNAME(PERSISTENT_TOKEN_CLASS).token
#else
#define _TOKEN(token) _BUILD_TOKENS_OBJNAME(PERSISTENT_CLASS).token
#endif
#else
// define the set of tokens - this makes sure that the tokens exist in the map and that we only look them up the once
static uint16 __Tok__MapKey= (uint16)~0u; pdr.addString("__Key__",__Tok__MapKey);
static uint16 __Tok__MapVal= (uint16)~0u; pdr.addString("__Val__",__Tok__MapVal);
#define _PROP(token,name,type,logic,get,set) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _STRUCT(token,name,logic,write,read) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _PROP_MAP(token,name,keyType,valType,logic,getKey,getVal,set) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _STRUCT_MAP(token,name,keyType,logic,getKey,valWrite,read) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _FLAG(token,name,logic,code) static uint16 token= (uint16)~0u; pdr.addString(name,token);
PERSISTENT_DATA
#undef _PROP
#undef _STRUCT
#undef _PROP_MAP
#undef _STRUCT_MAP
#undef _FLAG
#define _TOKEN(token) token
#endif
// Add user-defined code
#ifdef PERSISTENT_PRE_STORE
PERSISTENT_PRE_STORE
#endif
// write the properties to the persistent data record
#define _PROP(token,name,type,logic,get,set)\
_PDR_TRACE(name);\
logic { type val=get; pdr.push(_TOKEN(token),val); }
#define _STRUCT(token,name,logic,write,read)\
_PDR_TRACE(name);\
logic { pdr.pushStructBegin(_TOKEN(token)); write; pdr.pushStructEnd(_TOKEN(token)); }
#define _PROP_MAP(token,name,keyType,valType,logic,getKey,getVal,set)\
_PDR_TRACE(name);\
{\
pdr.pushStructBegin(_TOKEN(token));\
logic { keyType __k=getKey; valType __v=getVal; pdr.push(_TOKEN(__Tok__MapKey),__k); pdr.push(_TOKEN(__Tok__MapVal),__v); }\
pdr.pushStructEnd(_TOKEN(token)); \
}
#define _STRUCT_MAP(token,name,keyType,logic,getKey,valWrite,read)\
_PDR_TRACE(name);\
{ \
pdr.pushStructBegin(_TOKEN(token));\
logic { keyType __k=getKey; pdr.push(_TOKEN(__Tok__MapKey),__k); pdr.pushStructBegin(_TOKEN(__Tok__MapVal)); valWrite; pdr.pushStructEnd(_TOKEN(__Tok__MapVal)); }\
pdr.pushStructEnd(_TOKEN(token)); \
}
#define _FLAG(token,name,logic,code)\
_PDR_TRACE(name);\
logic { pdr.push(_TOKEN(token)); }
PERSISTENT_DATA
#undef _PROP
#undef _STRUCT
#undef _PROP_MAP
#undef _STRUCT_MAP
#undef _FLAG
#undef _PDR_TRACE
#undef _TOKEN
// Add user-defined code
#ifdef PERSISTENT_POST_STORE
PERSISTENT_POST_STORE
#endif
#ifdef NL_DEBUG
//nldebug("PDR:store:"NL_MACRO_TO_STR(PERSISTENT_CLASS)"(leave)");
#endif
}
#endif // ndef PERSISTENT_NO_STORE
// define _PERSISTENT_APPLY_ARGS as either (<empty>) or (","<extra args>) for use in adding args to the apply() function prototype
#ifdef PERSISTENT_APPLY_ARGS
#define _PERSISTENT_APPLY_ARGS ,PERSISTENT_APPLY_ARGS
#else
#define _PERSISTENT_APPLY_ARGS
#endif
#ifndef PERSISTENT_NO_APPLY
// apply()
void PERSISTENT_CLASS::apply(CPersistentDataRecord &pdr _PERSISTENT_APPLY_ARGS)
{
#define DECORATE(x) #x
#define MY_H_AUTO(name) static NLMISC::CHTimer _timer(DECORATE(name)"_Apply"); NLMISC::CAutoTimer _auto(&_timer);
MY_H_AUTO(PERSISTENT_CLASS)
#undef MY_H_AUTO
#undef DECORATE
// PDR debug helper
#ifdef NL_DEBUG
//nldebug("PDR:apply:"NL_MACRO_TO_STR(PERSISTENT_CLASS)"(enter)");
# define _PDR_TRACE(name) //nldebug("PDR:apply:" NL_MACRO_TO_STR(PERSISTENT_CLASS) "." #name)
#else
# define _PDR_TRACE(name)
#endif
// define the set of tokens - this makes sure that the tokens exist in the map and that we only look them up the once
static uint16 __Tok__MapKey= (uint16)~0u; pdr.addString("__Key__",__Tok__MapKey);
static uint16 __Tok__MapVal= (uint16)~0u; pdr.addString("__Val__",__Tok__MapVal);
#define _PROP(token,name,type,logic,get,set) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _STRUCT(token,name,logic,write,read) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _PROP_MAP(token,name,keyType,valType,logic,getKey,getVal,set) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _STRUCT_MAP(token,name,keyType,logic,getKey,valWrite,read) static uint16 token= (uint16)~0u; pdr.addString(name,token);
#define _FLAG(token,name,logic,code) static uint16 token= (uint16)~0u; pdr.addString(name,token);
PERSISTENT_DATA
#undef _PROP
#undef _STRUCT
#undef _PROP_MAP
#undef _STRUCT_MAP
#undef _FLAG
// Add user-defined code at the start of the method
#ifdef PERSISTENT_PRE_APPLY
PERSISTENT_PRE_APPLY
#endif
// apply the properties from the persistent data record
#define _PROP(token,name,type,logic,get,set)\
_PDR_TRACE(name);\
if (nextToken==token) { H_AUTO(token); type val; pdr.pop(token,val); set; continue; }
#define _STRUCT(token,name,logic,write,read)\
_PDR_TRACE(name);\
if (nextToken==token) { H_AUTO(token##_STRUCT); pdr.popStructBegin(token); read; pdr.popStructEnd(token); continue; }
#define _PROP_MAP(token,name,keyType,valType,logic,getKey,getVal,set)\
_PDR_TRACE(name);\
if (nextToken==token) { H_AUTO(token##_Key); pdr.popStructBegin(token);\
while (!pdr.isEndOfStruct()) { H_AUTO(token##_Val); keyType key; pdr.pop(__Tok__MapKey,key); valType val; pdr.pop(__Tok__MapVal,val);set;}\
pdr.popStructEnd(token); continue; }
#define _STRUCT_MAP(token,name,keyType,logic,getKey,valWrite,read)\
_PDR_TRACE(name);\
if (nextToken==token) { H_AUTO(token##_Key); pdr.popStructBegin(token);\
while (!pdr.isEndOfStruct()) { H_AUTO(token##_Val_STRUCT); keyType key; pdr.pop(__Tok__MapKey,key);pdr.popStructBegin(__Tok__MapVal);read;pdr.popStructEnd(__Tok__MapVal);}\
pdr.popStructEnd(token); continue; }
#define _FLAG(token,name,logic,code)\
_PDR_TRACE(name);\
if (nextToken==token) { H_AUTO(token##_FLAG); pdr.pop(token); code; continue; }
while (!pdr.isEndOfStruct())
{
uint16 nextToken= pdr.peekNextToken();
// try to match the next token to one of the persistent data elements and 'continue' on success
PERSISTENT_DATA
// nlwarning("Skipping unrecognised token: %s",pdr.peekNextTokenName().c_str());
// if this is a structure then skip the whole thing
std::vector<uint16> stack;
do
{
H_AUTO(SkipUnknownStuff);
if (pdr.isStartOfStruct())
{
stack.push_back(pdr.peekNextToken());
pdr.popStructBegin(stack.back());
}
else if (pdr.isEndOfStruct())
{
pdr.popStructEnd(stack.back());
if (!stack.empty())
stack.pop_back();
}
else
{
pdr.popNextArg(pdr.peekNextToken());
}
}
while (!stack.empty() && !pdr.isEndOfData());
}
#undef _PROP
#undef _STRUCT
#undef _PROP_MAP
#undef _STRUCT_MAP
#undef _FLAG
#undef _PDR_TRACE
// Add user-defined code
#ifdef PERSISTENT_POST_APPLY
PERSISTENT_POST_APPLY
#endif
#ifdef NL_DEBUG
//nldebug("PDR:apply:"NL_MACRO_TO_STR(PERSISTENT_CLASS)"(leave)");
#endif
}
#endif // ndef PERSISTENT_NO_APPLY
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#undef PROP
#undef PROP2
#undef LPROP
#undef LPROP2
#undef PROP_SET
#undef PROP_VECT
#undef LPROP_VECT
#undef LPROP_VECT2
#undef PROP_MAP
#undef PROP_MAP2
#undef LPROP_MAP2
#undef STRUCT
#undef STRUCT2
#undef LSTRUCT
#undef LSTRUCT2
#undef STRUCT_VECT
#undef LSTRUCT_VECT
#undef STRUCT_PTR_VECT
#undef STRUCT_MAP
#undef LSTRUCT_MAP2
#undef MAP_LOGIC
#undef SET_LOGIC
#undef VECT_LOGIC
#undef ARRAY_LOGIC
#undef DEFAULT_LOGIC
#undef _PERSISTENT_STORE_ARGS
#undef _PERSISTENT_APPLY_ARGS
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
#ifdef PERSISTENT_MACROS_AUTO_UNDEF
#undef PERSISTENT_CLASS
#undef PERSISTENT_DATA
#ifdef PERSISTENT_TOKEN_CLASS
#undef PERSISTENT_TOKEN_CLASS
#endif
#ifdef PERSISTENT_PRE_APPLY
#undef PERSISTENT_PRE_APPLY
#endif
#ifdef PERSISTENT_POST_APPLY
#undef PERSISTENT_POST_APPLY
#endif
#ifdef PERSISTENT_PRE_STORE
#undef PERSISTENT_PRE_STORE
#endif
#ifdef PERSISTENT_POST_STORE
#undef PERSISTENT_POST_STORE
#endif
#ifdef PERSISTENT_STORE_ARGS
#undef PERSISTENT_STORE_ARGS
#endif
#ifdef PERSISTENT_APPLY_ARGS
#undef PERSISTENT_APPLY_ARGS
#endif
#ifdef PERSISTENT_NO_STORE
#undef PERSISTENT_NO_STORE
#endif
#ifdef PERSISTENT_NO_APPLY
#undef PERSISTENT_NO_APPLY
#endif
#endif
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Reference in a new issue Copy permalink