/*
 * OpenClonk, http://www.openclonk.org
 *
 * Copyright (c) 2001-2009, RedWolf Design GmbH, http://www.clonk.de/
 * Copyright (c) 2009-2016, The OpenClonk Team and contributors
 *
 * Distributed under the terms of the ISC license; see accompanying file
 * "COPYING" for details.
 *
 * "Clonk" is a registered trademark of Matthes Bender, used with permission.
 * See accompanying file "TRADEMARK" for details.
 *
 * To redistribute this file separately, substitute the full license texts
 * for the above references.
 */
#ifndef STDADAPTORS_H
#define STDADAPTORS_H

#include "lib/StdCompiler.h"

// * Wrappers for C4Compiler-types

// Whole-line string, automatic size deduction (C4Compiler-String)
#define toC4CStr(szString) mkStringAdaptMA(szString)
#define toC4CStrBuf(rBuf) mkParAdapt(rBuf, StdCompiler::RCT_All)

// Integer-array with default 0, automatic size deduction
#define toC4CArr(rArr) mkArrayAdaptDM(rArr, 0)
#define toC4CArrU(rArr) mkArrayAdaptDM(rArr, 0u)

// * Null Adaptor
// Doesn't compile anything
struct StdNullAdapt
{
	inline void CompileFunc(StdCompiler *pComp) const { }
};

// * Defaulting Adaptor
// Sets default if CompileFunc fails with a Exception of type NotFoundException
template <class T, class D>
struct StdDefaultAdapt
{
	T &rValue; const D &rDefault;
	StdDefaultAdapt(T &rValue, const D &rDefault) : rValue(rValue), rDefault(rDefault) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		try
		{
#ifdef STDCOMPILER_EXCEPTION_WORKAROUND
			if (!pComp->ValueSafe(rValue))
				rValue = rDefault;
#else
			pComp->Value(rValue);
#endif
		}
		catch (StdCompiler::NotFoundException *pEx)
		{
			rValue = rDefault;
			delete pEx;
		}
	}
};
template <class T, class D>
inline StdDefaultAdapt<T, D> mkDefaultAdapt(T &&rValue, const D &rDefault) { return StdDefaultAdapt<T, D>(rValue, rDefault); }

// * Naming Adaptor
// Embeds a value into a named section, failsafe
// (use for values that do defaulting themselves - e.g. objects using naming)
template <class T>
struct StdNamingAdapt
{
	T &rValue; const char *szName;
	StdNamingAdapt(T &rValue, const char *szName) : rValue(rValue), szName(szName) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		pComp->Name(szName);
		try
		{
			pComp->Value(rValue);
		}
		catch (StdCompiler::Exception *)
		{
			pComp->NameEnd(true);
			throw;
		}
		pComp->NameEnd();
	}
	template <class D> inline bool operator == (const D &nValue) const { return rValue == nValue; }
	template <class D> inline StdNamingAdapt &operator = (const D &nValue) { rValue = nValue; return *this; }
};
template <class T>
inline StdNamingAdapt<T> mkNamingAdapt(T &&rValue, const char *szName) { return StdNamingAdapt<T>(rValue, szName); }

// * Naming Adaptor (defaulting)
// Embeds a value into a named section, sets default on fail
template <class T, class D>
struct StdNamingDefaultAdapt
{
	T &rValue; const char *szName; const D &rDefault; bool fPrefillDefault; bool fStoreDefault;
	StdNamingDefaultAdapt(T &rValue, const char *szName, const D &rDefault, bool fPrefillDefault, bool fStoreDefault) : rValue(rValue), szName(szName), rDefault(rDefault), fPrefillDefault(fPrefillDefault), fStoreDefault(fStoreDefault) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		// Default check
		if (pComp->hasNaming() && pComp->isSerializer() && rValue == rDefault && !fStoreDefault)
		{
			if (pComp->Default(szName)) return;
		}
		try
		{
			// Search named section, set default if not found
			if (pComp->Name(szName))
			{
				if (fPrefillDefault && pComp->isDeserializer()) rValue = rDefault; // default prefill if desired
				pComp->Value(mkDefaultAdapt(rValue, rDefault));
			}
			else
				rValue = rDefault;
		}
		catch (StdCompiler::Exception *)
		{
			pComp->NameEnd(true);
			throw;
		}
		// End section
		pComp->NameEnd();
	}
};
template <class T, class D>
inline StdNamingDefaultAdapt<T,D> mkNamingAdapt(T &&rValue, const char *szName, const D &rDefault, bool fPrefillDefault=false, bool fStoreDefault=false) { return StdNamingDefaultAdapt<T,D>(rValue, szName, rDefault, fPrefillDefault, fStoreDefault); }

// * Decompiling Adaptor
// Allows to use const objects if the compiler won't change the targets
template <class T>
struct StdDecompileAdapt
{
	const T &rValue;
	explicit StdDecompileAdapt(const T &rValue) : rValue(rValue) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		assert(pComp->isSerializer());
		pComp->Value(const_cast<T &>(rValue));
	}
	
	// make this work with in combination with StdParameterAdapt
	template<typename ... P>
	inline void CompileFunc(StdCompiler* pComp, P && ... pars) const
	{
		assert(pComp->isSerializer());
		pComp->Value(mkParAdapt(const_cast<T &>(rValue), std::forward<P>(pars)...));
	}
};
template <class T>
inline StdDecompileAdapt<T> mkDecompileAdapt(const T& rValue) { return StdDecompileAdapt<T>(rValue); }

// * Runtime value Adaptor
// Allows the C4ValueSetCompiler to set the value
template <class T>
struct StdRuntimeValueAdapt
{
	T &rValue;
	explicit StdRuntimeValueAdapt(T &rValue) : rValue(rValue) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		pComp->setRuntimeWritesAllowed(+1);
		pComp->Value(rValue);
		pComp->setRuntimeWritesAllowed(-1);
	}
	template <class D> inline bool operator == (const D &nValue) const { return rValue == nValue; }
	template <class D> inline StdRuntimeValueAdapt<T> &operator = (const D &nValue) { rValue = nValue; return *this; }
};
template <class T>
inline StdRuntimeValueAdapt<T> mkRuntimeValueAdapt(T &&rValue) { return StdRuntimeValueAdapt<T>(rValue); }

// * String adaptor
struct StdStringAdapt
{
	char *szString; int iMaxLength; StdCompiler::RawCompileType eRawType;
	StdStringAdapt(char *szString, int iMaxLength, StdCompiler::RawCompileType eRawType = StdCompiler::RCT_Escaped)
			: szString(szString), iMaxLength(iMaxLength), eRawType(eRawType) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		pComp->String(szString, iMaxLength, eRawType);
	}
	inline bool operator == (const char *szDefault) const { return SEqual(szString, szDefault); }
	inline StdStringAdapt &operator = (const char *szDefault) { SCopy(szDefault, szString, iMaxLength); return *this; }
};
inline StdStringAdapt mkStringAdapt(char *szString, int iMaxLength, StdCompiler::RawCompileType eRawType = StdCompiler::RCT_Escaped)
{ return StdStringAdapt(szString, iMaxLength, eRawType); }
template <size_t size> inline StdStringAdapt mkStringAdaptM(char (&szString)[size]) { return mkStringAdapt(szString, size); }
template <size_t size> inline StdStringAdapt mkStringAdaptMA(char (&szString)[size]) { return mkStringAdapt(szString, size, StdCompiler::RCT_All); }
template <size_t size> inline StdStringAdapt mkStringAdaptMI(char (&szString)[size]) { return mkStringAdapt(szString, size, StdCompiler::RCT_Idtf); }
template <size_t size> inline StdStringAdapt mkStringAdaptMIE(char (&szString)[size]) { return mkStringAdapt(szString, size, StdCompiler::RCT_IdtfAllowEmpty); }

// * std::string adaptor
struct StdStdStringAdapt
{
	std::string& string; StdCompiler::RawCompileType eRawType;
	StdStdStringAdapt(std::string& string, StdCompiler::RawCompileType eRawType = StdCompiler::RCT_Escaped)
		: string(string), eRawType(eRawType) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		pComp->String(string, eRawType);
	}
	inline bool operator == (const char *szDefault) const { return string == szDefault; }
	inline StdStdStringAdapt &operator = (const char *szDefault) { string = szDefault; return *this; }
};
inline StdStdStringAdapt mkStringAdapt(std::string& string, StdCompiler::RawCompileType eRawType = StdCompiler::RCT_Escaped)
{ return StdStdStringAdapt(string, eRawType); }
inline StdStdStringAdapt mkStringAdaptA(std::string& string)
{ return StdStdStringAdapt(string, StdCompiler::RCT_All); }

// * Raw adaptor
struct StdRawAdapt
{
	void *pData; size_t iSize; StdCompiler::RawCompileType eRawType;
	StdRawAdapt(void *pData, size_t iSize, StdCompiler::RawCompileType eRawType = StdCompiler::RCT_Escaped)
			: pData(pData), iSize(iSize), eRawType(eRawType) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		pComp->Raw(pData, iSize, eRawType);
	}
	inline bool operator == (const void *pDefault) const { return !memcmp(pDefault, pData, iSize); }
	inline StdRawAdapt &operator = (const void *pDefault) { memcpy(pData, pDefault, iSize); return *this; }
};
inline StdRawAdapt mkRawAdapt(void *pData, size_t iSize, StdCompiler::RawCompileType eRawType = StdCompiler::RCT_Escaped)
{ return StdRawAdapt(pData, iSize, eRawType); }
template <typename T>
inline StdRawAdapt mkRawAdaptM(T &val)
{
	// GCC 4.x doesn't support std::is_trivially_copyable
#if !defined(__GNUC__) || __GNUC__ > 4
	static_assert(std::is_trivially_copyable<T>::value, "StdRawAdapt: type must be trivially copyable");
#endif
	return mkRawAdapt(&val, sizeof(val));
}

// * Integer Adaptor
// Stores Integer-like datatypes (Enumerations)
template <class T, class int_t = int32_t>
struct StdIntAdapt
{
	T &rValue;
	explicit StdIntAdapt(T &rValue) : rValue(rValue) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		// Cast
		int_t iVal = int_t(rValue);
		pComp->Value(iVal);
		rValue = T(iVal);
	}
	// Operators for default checking/setting
	template <class D> inline bool operator == (const D &nValue) const { return rValue == nValue; }
	template <class D> inline StdIntAdapt &operator = (const D &nValue) { rValue = nValue; return *this; }
};
template <class T> inline StdIntAdapt<T> mkIntAdapt(T &rValue) { return StdIntAdapt<T>(rValue); }
template <class int_t, class T> StdIntAdapt<T, int_t> mkIntAdaptT(T &rValue) { return StdIntAdapt<T, int_t>(rValue); }

// * Casting Adaptor
// Does a reinterprete_cast
template <class T, class to_t>
struct StdCastAdapt
{
	T &rValue;
	explicit StdCastAdapt(T &rValue) : rValue(rValue) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		// Cast
		static_assert(sizeof(to_t) == sizeof(T), "CastAdapt sanity: sizes match");
		static_assert(std::is_pod<to_t>::value, "CastAdapt sanity: to-type is POD");
		static_assert(std::is_pod<T>::value, "CastAdapt sanity: from-type is POD");
		to_t vVal;
		std::memcpy(&vVal, &rValue, sizeof(to_t));
		pComp->Value(vVal);
		std::memcpy(&rValue, &vVal, sizeof(T));
	}
	// Operators for default checking/setting
	template <class D> inline bool operator == (const D &nValue) const { return rValue == nValue; }
	template <class D> inline StdCastAdapt &operator = (const D &nValue) { rValue = nValue; return *this; }
};
template <class to_t, class T> StdCastAdapt<T, to_t> mkCastAdapt(T &rValue) { return StdCastAdapt<T, to_t>(rValue); }
template <class T> StdCastAdapt<T, int32_t> mkCastIntAdapt(T &rValue) { return StdCastAdapt<T, int32_t>(rValue); }

// Helper: Identity function class
template <class T>
struct _IdFuncClass
{
	T &operator ()(T &rValue) const { return rValue; }
};

// * Array Adaptor
// Stores a separated list
template <class T, class M = _IdFuncClass<T> >
struct StdArrayAdapt
{
	StdArrayAdapt(T *pArray, int iSize, M && map = M())
			: pArray(pArray), iSize(iSize), map(std::forward<M>(map))
	{ }
	T *pArray; int iSize; M && map;
	inline void CompileFunc(StdCompiler *pComp) const
	{
		for (int i = 0; i < iSize; i++)
		{
			if (i) pComp->Separator(StdCompiler::SEP_SEP);
			pComp->Value(map(pArray[i]));
		}
	}
	// Operators for default checking/setting
	inline bool operator == (const T &rDefault) const
	{
		for (int i = 0; i < iSize; i++)
			if (pArray[i] != rDefault)
				return false;
		return true;
	}
	inline StdArrayAdapt &operator = (const T &rDefault)
	{
		for (int i = 0; i < iSize; i++)
			pArray[i] = rDefault;
		return *this;
	}
	inline bool operator == (const T *pDefaults) const
	{
		for (int i = 0; i < iSize; i++)
			if (pArray[i] != pDefaults[i])
				return false;
		return true;
	}
	inline StdArrayAdapt &operator = (const T *pDefaults)
	{
		for (int i = 0; i < iSize; i++)
			pArray[i] = pDefaults[i];
		return *this;
	}
};
template <class T>
inline StdArrayAdapt<T> mkArrayAdapt(T *pArray, int iSize) { return StdArrayAdapt<T>(pArray, iSize); }
template <class T, size_t size>
inline StdArrayAdapt<T> mkArrayAdaptM(T (&array)[size]) { return StdArrayAdapt<T>(array, size); }
template <class T, class M>
inline StdArrayAdapt<T, M> mkArrayAdaptMap(T *pArray, int iSize, M && map) { return StdArrayAdapt<T, M>(pArray, iSize, std::forward<M>(map)); }
template <class T, class M, size_t size>
inline StdArrayAdapt<T, M> mkArrayAdaptMapM(T (&array)[size], M && map) { return StdArrayAdapt<T, M>(array, size, std::forward<M>(map)); }

// * Array Adaptor (defaulting)
// Stores a separated list, sets defaults if a value or separator is missing.
template <class T, class D, class M = _IdFuncClass<T> >
struct StdArrayDefaultAdapt
{
	StdArrayDefaultAdapt(T *pArray, size_t iSize, const D &rDefault, const M &map = M())
			: pArray(pArray), iSize(iSize), rDefault(rDefault), map(map)
	{ }
	T *pArray; size_t iSize; const D &rDefault; const M map;
	inline void CompileFunc(StdCompiler *pComp) const
	{
		size_t i, iWrite = iSize;
		bool deserializing = pComp->isDeserializer();
		// Decompiling: Omit defaults
		if (!deserializing && pComp->hasNaming())
			while (iWrite > 0 && pArray[iWrite - 1] == rDefault)
				iWrite--;
		// Read/write values
		for (i = 0; i < iWrite; i++)
		{
			// Separator?
			if (i) if (!pComp->Separator(StdCompiler::SEP_SEP)) break;
			// Expect a value. Default if not found.
			pComp->Value(mkDefaultAdapt(map(pArray[i]), rDefault));
		}
		// Fill rest of array
		if (deserializing)
			for (; i < iSize; i++)
				pArray[i] = rDefault;
	}
	// Additional defaulting (whole array)
	inline bool operator == (const T *pDefaults) const
	{
		for (size_t i = 0; i < iSize; i++)
			if (pArray[i] != pDefaults[i])
				return false;
		return true;
	}
	inline StdArrayDefaultAdapt &operator = (const T *pDefaults)
	{
		for (size_t i = 0; i < iSize; i++)
			pArray[i] = pDefaults[i];
		return *this;
	}
};
template <class T, class D>
inline StdArrayDefaultAdapt<T, D> mkArrayAdapt(T *pArray, size_t iSize, const D &rDefault) { return StdArrayDefaultAdapt<T, D>(pArray, iSize, rDefault); }
template <class T, class D, size_t size>
inline StdArrayDefaultAdapt<T, D> mkArrayAdaptDM(T (&array)[size], const D &rDefault) { return StdArrayDefaultAdapt<T, D>(array, size, rDefault); }
template <class T, class D, class M>
inline StdArrayDefaultAdapt<T, D, M> mkArrayAdaptMap(T *pArray, size_t iSize, const D &rDefault, M map) { return StdArrayDefaultAdapt<T, D, M>(pArray, iSize, rDefault, map); }
template <class T, class D, class M, size_t size>
inline StdArrayDefaultAdapt<T, D, M> mkArrayAdaptMapDM(T (&array)[size], const D &rDefault, M map) { return StdArrayDefaultAdapt<T, D, M>(array, size, rDefault, map); }

// * Array Adaptor (defaulting to another array)
// Stores a separated list, sets defaults if a value or separator is missing.
template <class T, class D, class M = _IdFuncClass<T> >
struct StdArrayDefaultArrayAdapt
{
	StdArrayDefaultArrayAdapt(T *pArray, size_t iSize, const D &rDefault, const M &map = M())
			: pArray(pArray), iSize(iSize), rDefault(rDefault), map(map)
	{ }
	T *pArray; size_t iSize; const D &rDefault; const M map;
	inline void CompileFunc(StdCompiler *pComp) const
	{
		size_t i, iWrite = iSize;
		bool deserializing = pComp->isDeserializer();
		// Decompiling: Omit defaults
		if (!deserializing && pComp->hasNaming())
			while (iWrite > 0 && pArray[iWrite - 1] == rDefault[iWrite - 1])
				iWrite--;
		// Read/write values
		for (i = 0; i < iWrite; i++)
		{
			// Separator?
			if (i) if (!pComp->Separator(StdCompiler::SEP_SEP)) break;
			// Expect a value. Default if not found.
			pComp->Value(mkDefaultAdapt(map(pArray[i]), rDefault[i]));
		}
		// Fill rest of array
		if (deserializing)
			for (; i < iSize; i++)
				pArray[i] = rDefault[i];
	}
	// Additional defaulting (whole array)
	inline bool operator == (const T *pDefaults) const
	{
		for (size_t i = 0; i < iSize; i++)
			if (pArray[i] != pDefaults[i])
				return false;
		return true;
	}
	inline StdArrayDefaultArrayAdapt &operator = (const T *pDefaults)
	{
		for (size_t i = 0; i < iSize; i++)
			pArray[i] = pDefaults[i];
		return *this;
	}
};
template <class T, class D>
inline StdArrayDefaultArrayAdapt<T, D> mkArrayAdaptDefArr(T *pArray, size_t iSize, const D &rDefault) { return StdArrayDefaultArrayAdapt<T, D>(pArray, iSize, rDefault); }
template <class T, class D, size_t size>
inline StdArrayDefaultArrayAdapt<T, D> mkArrayAdaptDMA(T (&array)[size], const D &rDefault) { return StdArrayDefaultArrayAdapt<T, D>(array, size, rDefault); }
template <class T, class D, class M>
inline StdArrayDefaultArrayAdapt<T, D, M> mkArrayAdaptDefArrMap(T *pArray, size_t iSize, const D &rDefault, const M &map) { return StdArrayDefaultArrayAdapt<T, D, M>(pArray, iSize, rDefault, map); }
template <class T, class D, class M, size_t size>
inline StdArrayDefaultArrayAdapt<T, D, M> mkArrayAdaptDMAM(T (&array)[size], const D &rDefault, const M &map) { return StdArrayDefaultArrayAdapt<T, D, M>(array, size, rDefault, map); }

// * Insertion Adaptor
// Compile a value before / after another
template <class T, class I>
struct StdInsertAdapt
{
	StdInsertAdapt(T &rObj, I &rIns, bool fBefore = true)
			: rObj(rObj), rIns(rIns), fBefore(fBefore)
	{ }
	T &rObj; I &rIns; bool fBefore;
	void CompileFunc(StdCompiler *pComp) const
	{
		if (fBefore) pComp->Value(rIns);
		pComp->Value(rObj);
		if (!fBefore) pComp->Value(rIns);
	}
};
template <class T, class I>
inline StdInsertAdapt<T, I> mkInsertAdapt(T &&rObj, I &&rIns, bool fBefore = true) { return StdInsertAdapt<T,I>(rObj, rIns, fBefore); }

// * Parameter Adaptor
// Specify a second parameter for the CompileFunc
template <class T, class P>
struct StdParameterAdapt
{
	StdParameterAdapt(T && rObj, P && rPar) : rObj(std::forward<T>(rObj)), Par(std::forward<P>(rPar)) { }
	T && rObj; P && Par;
	void CompileFunc(StdCompiler *pComp) const
	{
		std::forward<T>(rObj).CompileFunc(pComp, std::forward<P>(Par));
	}
	// Operators for default checking/setting
	template <class D> inline bool operator == (const D &nValue) const { return rObj == nValue; }
	template <class D> inline StdParameterAdapt &operator = (const D &nValue) { rObj = nValue; return *this; }

	// getting value
	inline T && GetObj() { return std::forward<T>(rObj); }
};
template <class T, class P>
inline StdParameterAdapt<T, P> mkParAdapt(T && rObj, P && rPar)
{ return StdParameterAdapt<T, P>(std::forward<T>(rObj), std::forward<P>(rPar)); }

// for mkArrayAdaptMap
template <class P>
struct StdParameterAdaptMaker
{
	P && Par;
	StdParameterAdaptMaker(P && rPar) : Par(std::forward<P>(rPar)) { }
	template <class T>
	StdParameterAdapt<T, P> operator ()(T && rObj) const { return StdParameterAdapt<T, P>(std::forward<T>(rObj), std::forward<P>(Par)); }
};
template <class P>
inline StdParameterAdaptMaker<P> mkParAdaptMaker(P && rPar) { return StdParameterAdaptMaker<P>(std::forward<P>(rPar)); }

// * Parameter Adaptor 2
// Specify a second and a third parameter for the CompileFunc
template <class T, class P1, class P2>
struct StdParameter2Adapt
{
	StdParameter2Adapt(T && rObj, P1 && rPar1, P2 && rPar2) :
		rObj(std::forward<T>(rObj)), rPar1(std::forward<P1>(rPar1)), rPar2(std::forward<P2>(rPar2)) { }
	T && rObj; P1 && rPar1; P2 && rPar2;
	void CompileFunc(StdCompiler *pComp) const
	{
		std::forward<T>(rObj).CompileFunc(pComp, std::forward<P1>(rPar1), std::forward<P2>(rPar2));
	}
	// Operators for default checking/setting
	template <class D> inline bool operator == (const D &nValue) const { return rObj == nValue; }
	template <class D> inline StdParameter2Adapt &operator = (const D &nValue) { rObj = nValue; return *this; }
};
template <class T, class P1, class P2>
inline StdParameter2Adapt<T, P1, P2> mkParAdapt(T && rObj, P1 && rPar1, P2 && rPar2)
{ return StdParameter2Adapt<T, P1, P2>(std::forward<T>(rObj), std::forward<P1>(rPar1), std::forward<P2>(rPar2)); }

template <class T>
struct StdBasicPtrAdapt
{
	StdBasicPtrAdapt(T *&rpObj, bool fAllowNull = true, const char *szNaming = "Data")
		: rpObj(rpObj), fAllowNull(fAllowNull), szNaming(szNaming) {}
	T *&rpObj; bool fAllowNull; const char *szNaming;

	// Operators for default checking/setting
	inline bool operator == (const T &nValue) const { return rpObj && *rpObj == nValue; }
	inline StdBasicPtrAdapt &operator = (const T &nValue) { delete rpObj; rpObj = new T(nValue); return *this; }
	inline bool operator == (const T *pValue) const { return rpObj == pValue; }
	inline StdBasicPtrAdapt &operator = (const T *pValue) { delete rpObj; rpObj = pValue; return *this; }
};

// * Store pointer (contents)
// Defaults to null
template <class T>
struct StdPtrAdapt: StdBasicPtrAdapt<T>
{
	StdPtrAdapt(T *&rpObj, bool fAllowNull = true, const char *szNaming = "Data")
			: StdBasicPtrAdapt<T>(rpObj, fAllowNull, szNaming)
	{ }

	void CompileFunc(StdCompiler *pComp) const
	{
		StdPtrAdaptCompileFunc(pComp, *this);
	}

	// For use with StdParAdapt
	template<typename ... P>
	void CompileFunc(StdCompiler *pComp, P && ...pars)
	{
		StdPtrAdaptCompileFunc(pComp, *this, std::forward<P>(pars)...);
	}
};

template <class T, class ContextT>
struct StdContextPtrAdapt: StdBasicPtrAdapt<T>
{
	StdContextPtrAdapt(T *&rpObj, const ContextT& rCtx, bool fAllowNull = true, const char *szNaming = "Data")
		: StdBasicPtrAdapt<T>(rpObj, fAllowNull, szNaming), pCtx(&rCtx)
	{ }

	const ContextT* pCtx;

	void CompileFunc(StdCompiler *pComp) const
	{
		StdPtrAdaptCompileFunc(pComp, *this);
	}

	// For use with StdParAdapt
	template<class P>
	void CompileFunc(StdCompiler *pComp, const P& p)
	{
		StdPtrAdaptCompileFunc(pComp, *this, p);
	}
};

template <class T, typename ... P>
void StdPtrAdaptCompileFunc(StdCompiler* pComp, const T& adapt, P && ...pars)
{
	bool deserializing = pComp->isDeserializer(),
		fNaming = pComp->hasNaming();
	// Compiling? Clear object before
	if(deserializing) { delete adapt.rpObj; adapt.rpObj = nullptr; }
	// Null checks - different with naming support.
	if(adapt.fAllowNull)
		if(fNaming)
		{
			// Null check: just omit when writing
			if(!deserializing && !adapt.rpObj) return;
			// Set up naming
			if(!pComp->Name(adapt.szNaming)) { assert(deserializing); pComp->NameEnd(); return; }
		}
		else
		{
			bool fNull = !! adapt.rpObj;
			pComp->Value(fNull);
			// Null? Nothing further to do
			if(fNull) return;
		}
	else if(!deserializing)
		assert(adapt.rpObj);
	// Compile value
	if(deserializing)
		StdPtrAdaptCompileNewFunc(adapt, pComp, std::forward<P>(pars)...);
	else
		StdPtrAdaptDecompileNewFunc(adapt, pComp, std::forward<P>(pars)...);

	// Close naming
	if(adapt.fAllowNull && fNaming) pComp->NameEnd();
}


template <class T, typename ... P>
void StdPtrAdaptCompileNewFunc(const StdPtrAdapt<T>& adapt, StdCompiler* pComp, P && ...pars) { CompileNewFunc(adapt.rpObj, pComp, std::forward<P>(pars)...); }
template <class T, class ContextT, typename ... P>
void StdPtrAdaptCompileNewFunc(const StdContextPtrAdapt<T, ContextT>& adapt, StdCompiler* pComp, P && ...pars) { CompileNewFuncCtx(adapt.rpObj, pComp, *adapt.pCtx, std::forward<P>(pars)...); }

template <class T>
void StdPtrAdaptDecompileNewFunc(const StdPtrAdapt<T>& adapt, StdCompiler* pComp) { pComp->Value(mkDecompileAdapt(*adapt.rpObj)); }
template <class T, class ContextT>
void StdPtrAdaptDecompileNewFunc(const StdContextPtrAdapt<T, ContextT>& adapt, StdCompiler* pComp) { pComp->Value(mkDecompileAdapt(*adapt.rpObj)); }
template <class T, typename ... P>
void StdPtrAdaptDecompileNewFunc(const StdPtrAdapt<T>& adapt, StdCompiler* pComp, P && ...pars) { pComp->Value(mkParAdapt(mkDecompileAdapt(*adapt.rpObj), std::forward<P>(pars)...)); }
template <class T, class ContextT, typename ... P>
void StdPtrAdaptDecompileNewFunc(const StdContextPtrAdapt<T, ContextT>& adapt, StdCompiler* pComp, P && ...pars) { pComp->Value(mkParAdapt(mkDecompileAdapt(*adapt.rpObj), std::forward<P>(pars)...)); }

template <class T>
inline StdPtrAdapt<T> mkPtrAdapt(T *&rpObj, bool fAllowNull = true) { return StdPtrAdapt<T>(rpObj, fAllowNull); }
template <class T>
inline StdPtrAdapt<T> mkNamingPtrAdapt(T *&rpObj, const char *szNaming) { return StdPtrAdapt<T>(rpObj, true, szNaming); }
template <class T>
inline StdPtrAdapt<T> mkPtrAdaptNoNull(T *&rpObj) { return mkPtrAdapt<T>(rpObj, false); }

template <class T, class ContextT>
inline StdContextPtrAdapt<T, ContextT> mkContextPtrAdapt(T *&rpObj, const ContextT& ctx, bool fAllowNull = true) { return StdContextPtrAdapt<T, ContextT>(rpObj, ctx, fAllowNull); }
template <class T, class ContextT>
inline StdContextPtrAdapt<T, ContextT> mkNamingContextPtrAdapt(T *&rpObj, const ContextT& ctx, const char* szNaming) { return StdContextPtrAdapt<T, ContextT>(rpObj, ctx, true, szNaming); }
template <class T, class ContextT>
inline StdContextPtrAdapt<T, ContextT> mkContextPtrAdaptNoNull(T *&rpObj, const ContextT& ctx) { return mkContextPtrAdapt<T, ContextT>(rpObj, ctx, false); }

// * Adaptor for STL containers
// Writes a comma-separated list for compilers that support it. Otherwise, the size is calculated and safed.
// The defaulting uses the standard STL operators (full match)
template <class C>
struct StdSTLContainerAdapt
{
	StdSTLContainerAdapt(C &rStruct, StdCompiler::Sep eSep = StdCompiler::SEP_SEP)
			: rStruct(rStruct), eSep(eSep) { }
	C &rStruct; const StdCompiler::Sep eSep;
	inline void CompileFunc(StdCompiler *pComp) const
	{
		typedef typename C::value_type T;
		// Get compiler specs
		bool deserializing = pComp->isDeserializer();
		bool fNaming = pComp->hasNaming();
		// Decompiling?
		if (!deserializing)
		{
			// Write size (binary only)
			if (!fNaming)
			{
				int32_t iSize = rStruct.size();
				pComp->Value(iSize);
			}
			// Write all entries
			for (typename C::const_iterator i = rStruct.begin(); i != rStruct.end(); ++i)
			{
				if (i != rStruct.begin() && eSep) pComp->Separator(eSep);
				pComp->Value(const_cast<T &>(*i));
			}
		}
		else
		{
			// Compiling: Empty previous
			rStruct.clear();
			// Read size (binary only)
			uint32_t iSize;
			if (!fNaming) pComp->Value(iSize);
			// Read new
			do
			{
				// No entries left to read?
				if (!fNaming && !iSize--)
					break;
				// Read entries
				try
				{
					T val;
					pComp->Value(val);
					rStruct.push_back(val);
				}
				catch (StdCompiler::NotFoundException *pEx)
				{
					// No value found: Stop reading loop
					delete pEx;
					break;
				}
			}
			while (!eSep || pComp->Separator(eSep));
		}
	}
	// Operators for default checking/setting
	inline bool operator == (const C &nValue) const { return rStruct == nValue; }
	inline StdSTLContainerAdapt &operator = (const C &nValue) { rStruct = nValue; return *this; }
};
template <class C>
inline StdSTLContainerAdapt<C> mkSTLContainerAdapt(C &rTarget, StdCompiler::Sep eSep = StdCompiler::SEP_SEP) { return StdSTLContainerAdapt<C>(rTarget, eSep); }

// Write an integer that is supposed to be small most of the time. The adaptor writes it in
// 7-bit-pieces, bit 8 being a continuation marker: If it's set, more data is following, if not,
// all following bits are 0.
// Code lengths for uint32_t:
// 0x00000000 (0)         - 0x0000007F (127)        : 1 byte
// 0x00000080 (128)       - 0x00003FFF (16383)      : 2 byte
// 0x00004000 (16384)     - 0x001FFFFF (2097151)    : 3 byte
// 0x00200000 (2097152)   - 0x0FFFFFFF (268435456)  : 4 byte
// 0x10000000 (268435456) - 0xFFFFFFFF (4294967295) : 5 byte
// So this sort of packing is always useful when the integer in question is almost impossible to
// grow bigger than 2,097,151.
template <class T>
struct StdIntPackAdapt
{
	StdIntPackAdapt(T &rVal) : rVal(rVal) { }
	T &rVal;

	inline T clearUpper(T x) const
	{
		const int CLEARBITS = 8 * sizeof(T) - 7;
		return (x << CLEARBITS) >> CLEARBITS;
	}

	void CompileFunc(StdCompiler *pComp) const
	{
		// simply write for textual compilers
		if (pComp->hasNaming())
		{
			pComp->Value(rVal);
			return;
		}
		T val; uint8_t tmp;
		// writing?
		if (!pComp->isDeserializer())
		{
			val = rVal;
			for (;;)
			{
				tmp = uint8_t(clearUpper(val));
				// last byte?
				if (clearUpper(val) == val)
					break;
				// write byte
				tmp ^= 0x80; pComp->Value(tmp);
				// advance
				val >>= 7;
			}
			// write last byte
			pComp->Value(tmp);
		}
		// reading?
		else
		{
			// read first byte
			pComp->Value(tmp);
			val = clearUpper(T(tmp));
			// read remaining bytes
			int i = 7; T data = val;
			while ( uint8_t(data) != tmp )
			{
				// read byte
				pComp->Value(tmp);
				// add to value
				data = clearUpper(T(tmp));
				val = (data << i) | (val & ((1 << i) - 1));
				// next byte
				i+=7;
			}
			// write
			rVal = val;
		}
	}
	template <class D> inline bool operator == (const D &nValue) const { return rVal == nValue; }
	template <class D> inline StdIntPackAdapt &operator = (const D &nValue) { rVal = nValue; return *this; }
};
template <class T>
StdIntPackAdapt<T> mkIntPackAdapt(T &rVal) { return StdIntPackAdapt<T>(rVal); }

template <class T>
struct StdEnumEntry
{
	const char *Name;
	T Val;
};

// Enumeration: For text compilers, write a given name for a value.
// For everything else, just write an integer of given type.
template <class T, class int_t = int32_t>
struct StdEnumAdapt
{
	typedef StdEnumEntry<T> Entry;

	StdEnumAdapt(T &rVal, const Entry *pNames) : rVal(rVal), pNames(pNames) { assert(pNames); }
	T &rVal; const Entry *pNames;

	void CompileFunc(StdCompiler *pComp) const
	{
		// Write as int
		if (!pComp->isVerbose())
		{
			pComp->Value(mkIntAdaptT<int_t>(rVal));
			return;
		}
		// writing?
		if (!pComp->isDeserializer())
		{
			// Find value
			const Entry *pName = pNames;
			for (; pName->Name; pName++)
				if (pName->Val == rVal)
				{
					// Put name
					pComp->String(const_cast<char **>(&pName->Name), StdCompiler::RCT_Idtf);
					break;
				}
			// No name found?
			if (!pName->Name)
				// Put value as integer
				pComp->Value(mkIntAdaptT<int_t>(rVal));
		}
		// reading?
		else
		{
			int_t val = 0;
#ifdef STDCOMPILER_EXCEPTION_WORKAROUND
			// Try to read as number
			if (!pComp->ValueSafe(val))
			{
				rVal = T(val);
#else
			// Try to read as number
			try
			{
				pComp->Value(val);
				rVal = T(val);
			}
			catch (StdCompiler::NotFoundException *pEx)
			{
				delete pEx;
#endif
				// Try to read as string
				StdStrBuf Name;
				pComp->Value(mkParAdapt(Name, StdCompiler::RCT_Idtf));
				// Search in name list
				const Entry *pName = pNames;
				for (; pName->Name; pName++)
					if (Name == pName->Name)
					{
						rVal = pName->Val;
						break;
					}
				// Not found? Warn
				if (!pName->Name)
					pComp->Warn("Unknown bit name: %s", Name.getData());
			}
		}
	}

	template <class D> inline bool operator == (const D &nValue) const { return rVal == nValue; }
	template <class D> inline StdEnumAdapt<T, int_t> &operator = (const D &nValue) { rVal = nValue; return *this; }
};
template <class T, class int_t>
StdEnumAdapt<T, int_t> mkEnumAdapt(T &rVal, const StdEnumEntry<T> *pNames) { return StdEnumAdapt<T, int_t>(rVal, pNames); }
template <class int_t, class T>
StdEnumAdapt<T, int_t> mkEnumAdaptT(T &rVal, const StdEnumEntry<T> *pNames) { return StdEnumAdapt<T, int_t>(rVal, pNames); }

template <class T>
struct StdBitfieldEntry
{
	const char *Name;
	T Val;
};

// Convert a bitfield into/from something like "foo | bar | baz", where "foo", "bar" and "baz" are given constants.
template <class T>
struct StdBitfieldAdapt
{
	typedef StdBitfieldEntry<T> Entry;

	StdBitfieldAdapt(T &rVal, const Entry *pNames) : rVal(rVal), pNames(pNames) { assert(pNames); }
	T &rVal; const Entry *pNames;

	void CompileFunc(StdCompiler *pComp) const
	{
		// simply write for non-verbose compilers
		if (!pComp->isVerbose())
		{
			pComp->Value(rVal);
			return;
		}
		// writing?
		if (!pComp->isDeserializer())
		{
			T val = rVal, orig_val = rVal;
			// Write until value is comsumed
			bool fFirst = true;
			for (const Entry *pName = pNames; pName->Name; pName++)
				if ((pName->Val & val) == pName->Val)
				{
					// Avoid writing meaningless none-values (e.g. Category=C4D_None|C4D_Object)
					if (orig_val && !pName->Val) continue;
					// Put "|"
					if (!fFirst) pComp->Separator(StdCompiler::SEP_VLINE);
					// Put name
					pComp->String(const_cast<char **>(&pName->Name), StdCompiler::RCT_Idtf);
					fFirst = false;
					// Remove bits
					val &= ~pName->Val;
				}
			// Anything left is written as number, or a simple 0 in case no default was used
			if (val || fFirst)
			{
				// Put "|"
				if (!fFirst) pComp->Separator(StdCompiler::SEP_VLINE);
				// Put value
				pComp->Value(val);
			}
		}
		// reading?
		else
		{
			T val = 0;
			// Read
			do
			{
#ifdef STDCOMPILER_EXCEPTION_WORKAROUND
				T tmp;
				// Try to read as number
				if (pComp->ValueSafe(tmp))
					val |= tmp;
				else
				{
#else
				// Try to read as number
				try
				{
					T tmp;
					pComp->Value(tmp);
					val |= tmp;
				}
				catch (StdCompiler::NotFoundException *pEx)
				{
					delete pEx;
#endif
					// Try to read as string
					StdStrBuf Name;
					pComp->Value(mkParAdapt(Name, StdCompiler::RCT_Idtf));
					// Search in name list
					const Entry *pName = pNames;
					for (; pName->Name; pName++)
						if (Name == pName->Name)
						{
							val |= pName->Val;
							break;
						}
					// Not found? Warn
					if (!pName->Name)
						pComp->Warn("Unknown bit name: %s", Name.getData());
				}
				// Expect separation
			} while (pComp->Separator(StdCompiler::SEP_VLINE));
			// Write value back
			rVal = val;
		}
	}

	template <class D> inline bool operator == (const D &nValue) const { return rVal == nValue; }
	template <class D> inline StdBitfieldAdapt<T> &operator = (const D &nValue) { rVal = nValue; return *this; }
};
template <class T>
StdBitfieldAdapt<T> mkBitfieldAdapt(T &rVal, const StdBitfieldEntry<T> *pNames) { return StdBitfieldAdapt<T>(rVal, pNames); }

// * Name count adapter
// For compilers without name support, this just compiles the given value. Otherwise, the count
// of given namings is returned on compiling, and nothing is done for decompiling (The caller
// has to make sure that an appropriate number of namings will be created)
template <class int_t>
struct StdNamingCountAdapt
{
	int_t &iCount; const char *szName;
	StdNamingCountAdapt(int_t &iCount, const char *szName) : iCount(iCount), szName(szName) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		if (pComp->hasNaming())
		{
			if (pComp->isDeserializer())
				iCount = pComp->NameCount(szName);
		}
		else
			pComp->Value(mkIntPackAdapt(iCount));
	}
};
template <class int_t>
inline StdNamingCountAdapt<int_t> mkNamingCountAdapt(int_t &iCount, const char *szName) { return StdNamingCountAdapt<int_t>(iCount, szName); }

// * Hex adapter
// Writes raw binary data in hexadecimal
class StdHexAdapt
{
	void *pData; size_t iSize;
public:
	StdHexAdapt(void *pData, size_t iSize) : pData(pData), iSize(iSize) { }
	inline void CompileFunc(StdCompiler *pComp) const
	{
		if (!pComp->isVerbose())
			pComp->Raw(pData, iSize);
		char szData[2+1]; bool deserializing = pComp->isDeserializer();
		for (size_t i = 0; i < iSize; i++)
		{
			uint8_t *pByte = reinterpret_cast<uint8_t *>(pData) + i;
			if (!deserializing) sprintf(szData, "%02x", *pByte);
			pComp->String(szData, 2, StdCompiler::RCT_Idtf);
			if (deserializing)
			{
				unsigned int b;
				if (sscanf(szData, "%02x", &b) != 1)
					pComp->excNotFound(i ? "hexadecimal data: bytes missing!" : "hexadecimal data missing!");
				*pByte = b;
			}
		}
	}
};
inline StdHexAdapt mkHexAdapt(void *pData, size_t iSize) { return StdHexAdapt(pData, iSize); }
template <class T>
inline StdHexAdapt mkHexAdapt(T &rData) { return StdHexAdapt(&rData, sizeof(rData)); }


#endif //STDADAPTORS_H