1

public/chunkfile.h

@@ -0,0 +1,197 @@
+//========= 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