source-engine/public/chunkfile.h

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//===========================================================================//

#ifndef CHUNKFILE_H
#define CHUNKFILE_H

#ifdef _WIN32
#pragma once
#endif

#include <stdio.h>
#include "tokenreader.h"


#define MAX_INDENT_DEPTH		80
#define MAX_KEYVALUE_LEN		1024


class CChunkFile;
class Vector2D;
class Vector;
class Vector4D;


//
// Modes for Open.
//
enum ChunkFileOpenMode_t
{
	ChunkFile_Read = 0,
	ChunkFile_Write,
};


//
// Return codes.
//
enum ChunkFileResult_t
{
	ChunkFile_Ok = 0,
	ChunkFile_Fail,
	ChunkFile_OpenFail,
	ChunkFile_EndOfChunk,
	ChunkFile_EOF,
	ChunkFile_UnexpectedEOF,
	ChunkFile_UnexpectedSymbol,
	ChunkFile_OutOfMemory,
	ChunkFile_StringTooLong,
	ChunkFile_NotHandled
};


enum ChunkType_t
{
	ChunkType_Key = 0,
	ChunkType_Chunk,
};


typedef ChunkFileResult_t (*DefaultChunkHandler_t)(CChunkFile *pFile, void *pData, char const *pChunkName);

typedef ChunkFileResult_t (*ChunkHandler_t)(CChunkFile *pFile, void *pData);
typedef ChunkFileResult_t (*KeyHandler_t)(const char *szKey, const char *szValue, void *pData);
typedef bool (*ChunkErrorHandler_t)(CChunkFile *pFile, const char *szChunkName, void *pData);


struct ChunkHandlerInfo_t
{
	char szChunkName[80];
	ChunkHandler_t pfnHandler;
	void *pData;
};


struct ChunkHandlerInfoNode_t
{
	ChunkHandlerInfo_t Handler;
	struct ChunkHandlerInfoNode_t *pNext;
};


//
// Consider handling chunks with handler objects instead of callbacks.
//
//class CChunkHandler
//{
//	virtual ChunkFileResult_t HandleChunk(const char *szName);
//	virtual ChunkFileResult_t HandleKey(const char *szKey, const char *szValue);
//	virtual bool HandleError(const char *szChunkName, ChunkFileResult_t eError);
//};


class CChunkHandlerMap
{
	public:

		CChunkHandlerMap(void);
		~CChunkHandlerMap(void);

		void AddHandler(const char *pszChunkName, ChunkHandler_t pfnHandler, void *pData);
		ChunkHandler_t GetHandler(const char *pszChunkName, void **pData);

		void SetErrorHandler(ChunkErrorHandler_t pfnHandler, void *pData);
		ChunkErrorHandler_t GetErrorHandler(void **pData);

	protected:

		ChunkHandlerInfoNode_t *m_pHandlers;
		ChunkErrorHandler_t m_pfnErrorHandler;
		void *m_pErrorData;
};


class CChunkFile
{
	public:

		CChunkFile(void);
		~CChunkFile(void);

		ChunkFileResult_t Open(const char *pszFileName, ChunkFileOpenMode_t eMode);
		ChunkFileResult_t Close(void);
		const char *GetErrorText(ChunkFileResult_t eResult);

		//
		// Functions for writing chunk files.
		//
		ChunkFileResult_t BeginChunk(const char *pszChunkName);
		ChunkFileResult_t EndChunk(void);

		ChunkFileResult_t WriteKeyValue(const char *pszKey, const char *pszValue);
		ChunkFileResult_t WriteKeyValueBool(const char *pszKey, bool bValue);
		ChunkFileResult_t WriteKeyValueColor(const char *pszKey, unsigned char r, unsigned char g, unsigned char b);
		ChunkFileResult_t WriteKeyValueFloat(const char *pszKey, float fValue);
		ChunkFileResult_t WriteKeyValueInt(const char *pszKey, int nValue);
		ChunkFileResult_t WriteKeyValuePoint(const char *pszKey, const Vector &Point);
		ChunkFileResult_t WriteKeyValueVector2(const char *pszKey, const Vector2D &vec);
		ChunkFileResult_t WriteKeyValueVector3(const char *pszKey, const Vector &vec);
		ChunkFileResult_t WriteKeyValueVector4( const char *pszKey, const Vector4D &vec);

		ChunkFileResult_t WriteLine(const char *pszLine);

		//
		// Functions for reading chunk files.
		//
		ChunkFileResult_t ReadChunk(KeyHandler_t pfnKeyHandler = NULL, void *pData = NULL);
		ChunkFileResult_t ReadNext(char *szKey, char *szValue, int nValueSize, ChunkType_t &eChunkType);
		ChunkFileResult_t HandleChunk(const char *szChunkName);
		void HandleError(const char *szChunkName, ChunkFileResult_t eError);

		// These functions should more really be named Parsexxx and possibly moved elsewhere.
		static bool ReadKeyValueBool(const char *pszValue, bool &bBool);
		static bool ReadKeyValueColor(const char *pszValue, unsigned char &chRed, unsigned char &chGreen, unsigned char &chBlue);
		static bool ReadKeyValueInt(const char *pszValue, int &nInt);
		static bool ReadKeyValueFloat(const char *pszValue, float &flFloat);
		static bool ReadKeyValuePoint(const char *pszValue, Vector &Point);
		static bool ReadKeyValueVector2(const char *pszValue, Vector2D &vec);
		static bool ReadKeyValueVector3(const char *pszValue, Vector &vec);
	    static bool ReadKeyValueVector4( const char *pszValue, Vector4D &vec);

		// The default chunk handler gets called before any other chunk handlers.
		//
		// If the handler returns ChunkFile_Ok, then it goes into the chunk.
		// If the handler returns ChunkFile_NotHandled, then the chunk is
		//   passed to the regular handlers.
		//
		// If you pass NULL in here, then it disables the default chunk handler.
		void SetDefaultChunkHandler( DefaultChunkHandler_t pHandler, void *pData );

		void PushHandlers(CChunkHandlerMap *pHandlerMap);
		void PopHandlers(void);

	protected:

		void BuildIndentString(char *pszDest, int nDepth);

		TokenReader m_TokenReader;

		FILE *m_hFile;
		char m_szErrorToken[80];
		char m_szIndent[MAX_INDENT_DEPTH];
		int m_nCurrentDepth;

		// See SetDefaultChunkHandler..
		DefaultChunkHandler_t	m_DefaultChunkHandler;
		void					*m_pDefaultChunkHandlerData;

		CChunkHandlerMap *m_HandlerStack[MAX_INDENT_DEPTH];
		int m_nHandlerStackDepth;
};


#endif // CHUNKFILE_H