libcmo21/LibCmo/CKStateChunk.hpp

#pragma once

#include "CKDefines.hpp"
#include "CKEnums.hpp"
#include <type_traits>
#include <cinttypes>

namespace LibCmo::CK2 {

	class CKStateChunk {
	public:
		//CKStateChunk();
		CKStateChunk(CKFileDocument* doc, CKMinContext* ctx);
		CKStateChunk(const CKStateChunk&);
		CKStateChunk& operator=(const CKStateChunk&);
		~CKStateChunk();

	private:
		enum class CKStateChunkStatus : int32_t {
			IDLE,
			READ,
			WRITE
		};

		CK_CLASSID m_ClassId;
		CKDWORD m_DataDwSize;
		CKDWORD* m_pData;

		CK_STATECHUNK_DATAVERSION m_DataVersion;
		CK_STATECHUNK_CHUNKVERSION m_ChunkVersion;

		struct {
			CKStateChunkStatus m_Status;
			CKDWORD m_CurrentPos;
			CKDWORD m_DataSize;
			CKDWORD m_PrevIdentifierPos;
		}m_Parser;

		std::vector<CKDWORD> m_ObjectList;
		std::vector<CKDWORD> m_ChunkList;
		std::vector<CKDWORD> m_ManagerList;

		CKFileDocument* m_BindDoc;
		CKMinContext* m_BindContext;

#pragma region Buffer Related

	public:
		bool ConvertFromBuffer(const void* buf);
		CKDWORD ConvertToBuffer(void* buf);

#pragma endregion

#pragma region Misc Functions

	public:
		//bool UnPack(CKDWORD DestSize);
		void Clear(void);
		CKDWORD GetDataSize(void);
		CK_STATECHUNK_DATAVERSION GetDataVersion();
		void SetDataVersion(CK_STATECHUNK_DATAVERSION version);
		void DeleteBuffer(void* buf);
		bool Skip(CKDWORD DwordCount);

	private:
		size_t GetCeilDwordSize(size_t char_size);
		bool ResizeBuffer(CKDWORD new_dwsize);
		bool EnsureWriteSpace(CKDWORD dwsize);
		bool EnsureReadSpace(CKDWORD dword_required);

#pragma endregion


#pragma region Read Function

	public:
		void StartRead(void);
		void StopRead(void);

		/* ========== Identifier Functions ==========*/

		bool SeekIdentifierDword(CKDWORD identifier);
		bool SeekIdentifierDwordAndReturnSize(CKDWORD identifier, CKDWORD* out_size);
		template<typename TEnum>
		inline bool SeekIdentifier(TEnum enum_v) {
			return SeekIdentifierDword(static_cast<CKDWORD>(enum_v));
		}
		template<typename TEnum>
		inline bool SeekIdentifierAndReturnSize(TEnum enum_v, CKDWORD* out_size) {
			return SeekIdentifierDwordAndReturnSize(static_cast<CKDWORD>(enum_v), out_size);
		}

		/* ========== Basic Data Read Functions ==========*/

	private:
		/// <summary>
		/// The base read function for all data.
		/// <para>This function will check all read requirements.</para>
		/// <para>If you have use this function or functions calling this function. You do not need check any reading requirements anymore</para>
		/// </summary>
		/// <param name="data_ptr">the pointer to data. must be allocated first.</param>
		/// <param name="size_in_byte">the size of data in byte.</param>
		/// <returns></returns>
		bool ReadByteData(void* data_ptr, CKDWORD size_in_byte);
	public:
		/// <summary>
		/// Read Struct
		/// <para>Primitive type: ReadInt, ReadByte, ReadWord, ReadDword, ReadFloat, etc...</para>
		/// <para>Struct type: ReadGuid, ReadVector, ReadMatrix, etc...</para>
		/// <para>Both of them are redirected to this.</para>
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="data"></param>
		/// <returns></returns>
		template<typename T>
		bool ReadStruct(T* data) {
			return ReadByteData(data, static_cast<CKDWORD>(sizeof(T)));
		}
		/// <summary>
		/// Read Struct
		/// <para>A wrapper for ReadStructPtr.</para>
		/// <para>Use reference, not pointer.</para>
		/// </summary>
		/// <typeparam name="T"></typeparam>
		/// <param name="data"></param>
		/// <returns></returns>
		template<typename T>
		inline bool ReadStruct(T& data) {
			return ReadByteData(&data, static_cast<CKDWORD>(sizeof(T)));
		}

		/// <summary>
		/// Read string
		/// </summary>
		/// <param name="strl"></param>
		/// <returns></returns>
		bool ReadString(std::string* strl);
		inline bool ReadString(std::string& strl) {
			return ReadString(&strl);
		}

		/* ========== Complex Data Read Functions ==========*/

		bool ReadObjectID(CK_ID* id);
		inline bool ReadObjectID(CK_ID& id) {
			return ReadObjectID(&id);
		}

		bool ReadManagerInt(CKGUID* guid, CKINT* intval);
		inline bool ReadManagerInt(CKGUID& guid, CKINT& intval) {
			return ReadManagerInt(&guid, &intval);
		}

		/// <summary>
		/// Read sub chunk
		/// <para>Return nullptr if failed.</para>
		/// <para>Returned CKStateChunk should be manually released!</para>
		/// </summary>
		/// <param name=""></param>
		/// <returns></returns>
		CKStateChunk* ReadSubChunk(void);

		/* ========== Buffer Functions ==========*/

		/*
		Buffer related function implements:

		ReadBuffer(void**)						Read Byte based size.		-> ReadBuffer
		ReadAndFillBuffer(int, void*)			User give Byte based size.	-> ReadNoSizeBuffer
		ReadAndFillBuffer(void*)				Read Byte based size.		-> ReadBuffer
		ReadAndFillBuffer_LEndian(int, void*)	User give Byte based size.	-> ReadNoSizeBuffer
		ReadAndFillBuffer_LEndian(void*)		Read Byte based size.		-> ReadBuffer
		ReadAndFillBuffer_LEndian16(int, void*)	User give Byte based size.	-> ReadNoSizeBuffer
		ReadAndFillBuffer_LEndian16(void*)		Read Byte based size.		-> ReadBuffer
		*/

		/// <summary>
		/// Read a buffer with unknow size (order user specific it).
		/// <para>ReadAndFillBuffer(int, void*), ReadAndFillBuffer_LEndian(int, void*), ReadAndFillBuffer_LEndian16(int, void*) are redirected to this.</para>
		/// <para>The buffer should be allocated by caller first.</para>
		/// </summary>
		/// <param name="size"></param>
		/// <param name="allocatedBuf"></param>
		/// <returns></returns>
		bool ReadNoSizeBuffer(CKDWORD size_in_byte, void* allocatedBuf);
		/// <summary>
		/// Read a buffer with knowen size stored in chunk.
		/// <para>ReadBuffer(void**), ReadAndFillBuffer(void*), ReadAndFillBuffer_LEndian(void*), ReadAndFillBuffer_LEndian16(void*) are redirected to this.</para>
		/// <para>The buffer will be allocated by function.</para>
		/// <para>Use CKStateChunk::DeleteBuffer() to delete it.</para>
		/// </summary>
		/// <param name="buf">a pointer to the pointer receiving data start address.</param>
		/// <param name="len">a pointer to the variable receiving the length of gotten buffer.</param>
		/// <returns></returns>
		bool ReadBuffer(void** buf, CKDWORD* len_in_byte);

		/* ========== Sequence Functions ==========*/

		/// <summary>
		/// Read Object ID Sequence
		/// <para>The combination using of StartReadSequence(), ReadObjectID(), and ReadObject() redirect to this.</para>
		/// </summary>
		/// <param name="ls"></param>
		/// <returns></returns>
		bool ReadObjectIDSequence(std::vector<CK_ID>* ls);
		inline bool ReadObjectIDSequence(std::vector<CK_ID>& ls) {
			return ReadObjectIDSequence(&ls);
		}

		/// <summary>
		/// Read Manager Sequence
		/// <para>The combination using of StartManagerReadSequence() and ReadManagerIntSequence() redirect to this.</para>
		/// </summary>
		/// <param name="guid"></param>
		/// <param name="ls"></param>
		/// <returns></returns>
		bool ReadManagerIntSequence(CKGUID* guid, std::vector<CKINT>* ls);
		inline bool ReadManagerIntSequence(CKGUID& guid, std::vector<CKINT>& ls) {
			return ReadManagerIntSequence(&guid, &ls);
		}

		/// <summary>
		/// Read Sub Chunk Sequence
		/// <para>The combination using of StartReadSequence() and ReadSubChunk() redirect to this.</para>
		/// <para>The item of returned CKStateChunk* list should be manually released!</para>
		/// </summary>
		/// <param name="ls"></param>
		/// <returns></returns>
		bool ReadSubChunkSequence(std::vector<CKStateChunk*>* ls);
		inline bool ReadSubChunkSequence(std::vector<CKStateChunk*>& ls) {
			return ReadSubChunkSequence(&ls);
		}

		/// <summary>
		/// Read Object Array (actually still is CK_ID)
		/// <para>ReadXObjectArray() and ReadObjectArray() redirect to this.</para>
		/// </summary>
		/// <param name="ls"></param>
		/// <returns></returns>
		bool ReadObjectArray(std::vector<CK_ID>* ls);
		inline bool ReadObjectArray(std::vector<CK_ID>& ls) {
			return ReadObjectArray(&ls);
		}

		//int		ReadInt();
		//int 		StartReadSequence();
		//CK_ID	ReadObjectID();
		//CKStateChunk* ReadSubChunk();
		//int 		StartManagerReadSequence(CKGUID* guid);
		//CKGUID	ReadGuid();
		//void ReadAndFillBuffer_LEndian(void* buffer);
		//void ReadAndFillBuffer_LEndian16(void* buffer);
		//float	ReadFloat();
		//CKWORD	ReadWord();
		//CKDWORD	ReadDword();
		//CKDWORD	ReadDwordAsWords();
		//void		ReadVector(VxMath::VxVector* v);
		//void		ReadMatrix(VxMath::VxMatrix& mat);
		//CKObjectImplements::CKObject* ReadObject(CKMinContext*);
		//void ReadAndFillBuffer(void* buffer);
		//CKBYTE* ReadRawBitmap(VxMath::VxImageDescEx& desc);
		//XObjectArray ReadXObjectArray(void);

#pragma endregion

#pragma region Write Function

	public:
		void StartWrite();
		//void WriteIdentifier(CKDWORD id);
		//void AddChunkAndDelete(CKStateChunk*);
		//void StartObjectIDSequence(int count);
		//void WriteObjectSequence(CKObjectImplements::CKObject* obj);
		//void WriteInt(int data);
		//void WriteFloat(float data);
		//void WriteDword(CKDWORD data);
		//void WriteDwordAsWords(CKDWORD data);
		//void WriteVector(const VxMath::VxVector* v);
		//void WriteMatrix(const VxMath::VxMatrix& mat);
		//void WriteObject(CKObjectImplements::CKObject* obj);
		//void WriteBuffer_LEndian(int size, void* buf);
		//void WriteBuffer_LEndian16(int size, void* buf);
		//void WriteBufferNoSize_LEndian(int size, void* buf);
		///*void UpdateDataSize();*/
		//void* LockWriteBuffer(int DwordCount);

		/*
		* Old Name: CloseChunk();
		*/
		void StopWrite(void);

#pragma endregion



	};

}