yyc12345/libcmo21
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove all std::nothrow and re-create namespace for objs and mgrs

Browse Source
This commit is contained in:
yyc12345 2023-08-26 16:37:26 +08:00
parent 91a37b5b7e
commit 47bf6ab6c6
18 changed files with 176 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
LibCmo/CK2/CKContext.cpp
View File

@ -1,5 +1,5 @@
#include "CKContext.hpp" #include "CKContext.hpp"
#include "CKObjectImplements/CKObject.hpp" #include "ObjImpls/CKObject.hpp"
#include <cstdarg> #include <cstdarg>
namespace LibCmo::CK2 { namespace LibCmo::CK2 {
@ -12,7 +12,7 @@ namespace LibCmo::CK2 {
#pragma region Objects Management #pragma region Objects Management
CKObject* CKContext::CreateCKObject(CK_CLASSID cls, CKSTRING name, ObjImpls::CKObject* CKContext::CreateCKObject(CK_CLASSID cls, CKSTRING name,
CK_OBJECTCREATION_OPTIONS options, CK_CREATIONMODE* res) { CK_OBJECTCREATION_OPTIONS options, CK_CREATIONMODE* res) {
// todo: Process paramter options and res // todo: Process paramter options and res
@ -33,7 +33,7 @@ namespace LibCmo::CK2 {
} }
// create one // create one
CKObject* obj = desc->CreationFct(this, decided_id, name); ObjImpls::CKObject* obj = desc->CreationFct(this, decided_id, name);
// put into slot // put into slot
m_ObjectsList[decided_id] = obj; m_ObjectsList[decided_id] = obj;
@ -42,7 +42,7 @@ namespace LibCmo::CK2 {
return obj; return obj;
} }
CKObject* CKContext::GetCKObject(CK_ID id) { ObjImpls::CKObject* CKContext::GetCKObject(CK_ID id) {
if (id >= m_ObjectsList.size()) return nullptr; if (id >= m_ObjectsList.size()) return nullptr;
return m_ObjectsList[id]; return m_ObjectsList[id];
} }
@ -52,7 +52,7 @@ namespace LibCmo::CK2 {
* @param[in] ctx The CKContext * @param[in] ctx The CKContext
* @param[in] obj The CKObject need to be free. * @param[in] obj The CKObject need to be free.
*/ */
static void InternalDestroy(CKContext* ctx, CKObject* obj) { static void InternalDestroy(CKContext* ctx, ObjImpls::CKObject* obj) {
// find desc by classid // find desc by classid
// if really we can not find it, we only can delete it directly. // if really we can not find it, we only can delete it directly.
const CKClassDesc* desc = CKGetClassDesc(obj->GetClassID()); const CKClassDesc* desc = CKGetClassDesc(obj->GetClassID());
@ -68,7 +68,7 @@ namespace LibCmo::CK2 {
if (id >= m_ObjectsList.size()) return; if (id >= m_ObjectsList.size()) return;
// get object and free it // get object and free it
CKObject* obj = m_ObjectsList[id]; ObjImpls::CKObject* obj = m_ObjectsList[id];
if (obj == nullptr) return; if (obj == nullptr) return;
InternalDestroy(this, obj); InternalDestroy(this, obj);
@ -103,8 +103,6 @@ namespace LibCmo::CK2 {
} }
} }
// todo: free all created managers
} }
#pragma endregion #pragma endregion

6
LibCmo/CK2/CKContext.hpp
View File

@ -37,10 +37,10 @@ namespace LibCmo::CK2 {
* @remark CKObjects must be destroy with the DestroyObject method. * @remark CKObjects must be destroy with the DestroyObject method.
* @see CKObject, DestroyObject * @see CKObject, DestroyObject
*/ */
CKObject* CreateCKObject(CK_CLASSID cls, CKSTRING name, ObjImpls::CKObject* CreateCKObject(CK_CLASSID cls, CKSTRING name,
CK_OBJECTCREATION_OPTIONS options = CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_NONAMECHECK, CK_OBJECTCREATION_OPTIONS options = CK_OBJECTCREATION_OPTIONS::CK_OBJECTCREATION_NONAMECHECK,
CK_CREATIONMODE* res = nullptr); CK_CREATIONMODE* res = nullptr);
CKObject* GetCKObject(CK_ID id); ObjImpls::CKObject* GetCKObject(CK_ID id);
void DestroyCKObject(CK_ID id); void DestroyCKObject(CK_ID id);
// ========== Object Access ========== // ========== Object Access ==========
@ -77,7 +77,7 @@ namespace LibCmo::CK2 {
protected: protected:
// ========== Objects Management ========== // ========== Objects Management ==========
XContainer::XArray<CKObject*> m_ObjectsList; XContainer::XArray<ObjImpls::CKObject*> m_ObjectsList;
std::deque<CK_ID> m_ReturnedObjectIds; std::deque<CK_ID> m_ReturnedObjectIds;
// ========== Encoding utilities ========== // ========== Encoding utilities ==========

9
LibCmo/CK2/CKDefines.hpp
View File

@ -22,8 +22,8 @@ namespace LibCmo::CK2 {
// ========== Class registration utilities ========== // ========== Class registration utilities ==========
//using CKClassRegisterFct = std::function<void()>; //using CKClassRegisterFct = std::function<void()>;
using CKClassCreationFct = std::function<CKObject* (CKContext*, CK_ID, CKSTRING)>; using CKClassCreationFct = std::function<ObjImpls::CKObject* (CKContext*, CK_ID, CKSTRING)>;
using CKClassReleaseFct = std::function<void(CKContext*, CKObject*)>; using CKClassReleaseFct = std::function<void(CKContext*, ObjImpls::CKObject*)>;
using CKClassNameFct = std::function<CKSTRING()>; using CKClassNameFct = std::function<CKSTRING()>;
//using CKClassDependenciesFct = std::function<CKSTRING(CKINT, CKINT)>; //using CKClassDependenciesFct = std::function<CKSTRING(CKINT, CKINT)>;
//using CKClassDependenciesCountFct = std::function<CKINT(CKINT)>; //using CKClassDependenciesCountFct = std::function<CKINT(CKINT)>;
@ -63,10 +63,7 @@ namespace LibCmo::CK2 {
DerivationLevel(0), DerivationLevel(0),
Parents(), Children() Parents(), Children()
{} {}
CKClassDesc(const CKClassDesc& rhs) = default; LIBCMO_DEFAULT_COPY_MOVE(CKClassDesc);
CKClassDesc(CKClassDesc&& rhs) = default;
CKClassDesc& operator=(const CKClassDesc& rhs) = default;
CKClassDesc& operator=(CKClassDesc& rhs) = default;
}; };
} }

4
LibCmo/CK2/CKFile.hpp
View File

@ -104,7 +104,7 @@ namespace LibCmo::CK2 {
CK_ID ObjectId; /**< ID of the object being load/saved (as it will be/was saved in the file) */ CK_ID ObjectId; /**< ID of the object being load/saved (as it will be/was saved in the file) */
CK_ID CreatedObjectId; /**< ID of the object being created */ CK_ID CreatedObjectId; /**< ID of the object being created */
CK_CLASSID ObjectCid; /**< Class Identifier of the object */ CK_CLASSID ObjectCid; /**< Class Identifier of the object */
CKObject* ObjPtr; /**< A pointer to the object itself (as CreatedObject when loading) */ ObjImpls::CKObject* ObjPtr; /**< A pointer to the object itself (as CreatedObject when loading) */
TypeHelper::MKString Name; /**< Name of the Object */ TypeHelper::MKString Name; /**< Name of the Object */
CKStateChunk* Data; /**< A CKStateChunk that contains object information */ CKStateChunk* Data; /**< A CKStateChunk that contains object information */
//CKINT PostPackSize; /**< When compressed chunk by chunk : size of Data after compression */ //CKINT PostPackSize; /**< When compressed chunk by chunk : size of Data after compression */
@ -197,7 +197,7 @@ namespace LibCmo::CK2 {
LIBCMO_DISABLE_COPY_MOVE(CKFileWriter); LIBCMO_DISABLE_COPY_MOVE(CKFileWriter);
// ========== Saving Preparing ========== // ========== Saving Preparing ==========
CKBOOL AddSavedObject(CKObject* obj, CKDWORD flags = CK_STATESAVE_ALL); CKBOOL AddSavedObject(ObjImpls::CKObject* obj, CKDWORD flags = CK_STATESAVE_ALL);
CKBOOL AddSavedObjects(CKObjectArray* objarray, CKDWORD flags = CK_STATESAVE_ALL); CKBOOL AddSavedObjects(CKObjectArray* objarray, CKDWORD flags = CK_STATESAVE_ALL);
CKBOOL AddSavedFile(CKSTRING u8FileName); CKBOOL AddSavedFile(CKSTRING u8FileName);

2
LibCmo/CK2/CKFileOthers.cpp
View File

@ -149,7 +149,7 @@ namespace LibCmo::CK2 {
CKFileWriter::~CKFileWriter() {} CKFileWriter::~CKFileWriter() {}
CKBOOL CKFileWriter::AddSavedObject(CKObject* obj, CKDWORD flags) { CKBOOL CKFileWriter::AddSavedObject(ObjImpls::CKObject* obj, CKDWORD flags) {
return CKFALSE; return CKFALSE;
} }

7
LibCmo/CK2/CKFileReader.cpp
View File

@ -1,6 +1,6 @@
#include "CKFile.hpp" #include "CKFile.hpp"
#include "CKStateChunk.hpp" #include "CKStateChunk.hpp"
#include "CKObjectImplements/CKObject.hpp" #include "ObjImpls/CKObject.hpp"
#include "../VxMath/VxMemoryMappedFile.hpp" #include "../VxMath/VxMemoryMappedFile.hpp"
#include "CKContext.hpp" #include "CKContext.hpp"
#include <memory> #include <memory>
@ -190,8 +190,7 @@ namespace LibCmo::CK2 {
} }
CKERROR CKFileReader::ReadFileData(CKBufferParser* ParserPtr) { CKERROR CKFileReader::ReadFileData(CKBufferParser* ParserPtr) {
std::unique_ptr<CKBufferParser> parser(new(std::nothrow) CKBufferParser(ParserPtr->GetBase(), ParserPtr->GetSize(), false)); std::unique_ptr<CKBufferParser> parser(new CKBufferParser(ParserPtr->GetBase(), ParserPtr->GetSize(), false));
if (parser == nullptr) return CKERROR::CKERR_OUTOFMEMORY;
parser->SetCursor(ParserPtr->GetCursor()); parser->SetCursor(ParserPtr->GetCursor());
std::string name_conv; std::string name_conv;
@ -290,7 +289,7 @@ namespace LibCmo::CK2 {
// ========== included file get ========== // ========== included file get ==========
// before reading, we need switch back to original parser. // before reading, we need switch back to original parser.
// and skip data chunk size // and skip data chunk size
parser = std::unique_ptr<CKBufferParser>(new(std::nothrow) CKBufferParser(ParserPtr->GetBase(), ParserPtr->GetSize(), false)); parser = std::unique_ptr<CKBufferParser>(new CKBufferParser(ParserPtr->GetBase(), ParserPtr->GetSize(), false));
parser->MoveCursor(this->m_FileInfo.DataPackSize); parser->MoveCursor(this->m_FileInfo.DataPackSize);
// then we can read it. // then we can read it.

6
LibCmo/CK2/CKGlobals.cpp
View File

@ -10,7 +10,7 @@
#include <algorithm> #include <algorithm>
#include <zlib.h> #include <zlib.h>
#include "CKObjectImplements/CKObject.hpp" #include "ObjImpls/CKObject.hpp"
namespace LibCmo::CK2 { namespace LibCmo::CK2 {
@ -191,8 +191,8 @@ namespace LibCmo::CK2 {
CKERROR CKStartUp() { CKERROR CKStartUp() {
// todo: add class type registrations // todo: add class type registrations
CKClassRegister(CK_CLASSID::CKCID_OBJECT, CK_CLASSID::CKCID_OBJECT, CKClassRegister(CK_CLASSID::CKCID_OBJECT, CK_CLASSID::CKCID_OBJECT,
[](CKContext* ctx, CK_ID id, CKSTRING name) -> CKObject* { return new CKObject(ctx, id, name); }, [](CKContext* ctx, CK_ID id, CKSTRING name) -> ObjImpls::CKObject* { return new ObjImpls::CKObject(ctx, id, name); },
[](CKContext* ctx, CKObject* obj) -> void { delete obj; }, [](CKContext* ctx, ObjImpls::CKObject* obj) -> void { delete obj; },
[]() -> CKSTRING { return "Basic Object"; }); []() -> CKSTRING { return "Basic Object"; });
/* /*

90
LibCmo/CK2/CKStateChunk.cpp
View File

@ -18,7 +18,7 @@ namespace LibCmo::CK2 {
CKStateChunk::CKStateChunk(CKFileVisitor* visitor, CKContext* ctx) : CKStateChunk::CKStateChunk(CKFileVisitor* visitor, CKContext* ctx) :
m_ClassId(CK_CLASSID::CKCID_OBJECT), m_DataDwSize(0u), m_pData(nullptr), m_ClassId(CK_CLASSID::CKCID_OBJECT), m_DataDwSize(0u), m_pData(nullptr),
m_DataVersion(CK_STATECHUNK_DATAVERSION::CHUNKDATA_CURRENTVERSION), m_ChunkVersion(CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION4), m_DataVersion(CK_STATECHUNK_DATAVERSION::CHUNKDATA_CURRENTVERSION), m_ChunkVersion(CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION4),
m_Parser{ CKStateChunkStatus::IDLE, 0u, 0u, 0u }, m_Parser { CKStateChunkStatus::IDLE, 0u, 0u, 0u },
m_ObjectList(), m_ChunkList(), m_ManagerList(), m_ObjectList(), m_ChunkList(), m_ManagerList(),
m_BindFile(visitor), m_BindContext(ctx) m_BindFile(visitor), m_BindContext(ctx)
{} {}
@ -31,13 +31,23 @@ namespace LibCmo::CK2 {
m_BindFile(rhs.m_BindFile), m_BindContext(rhs.m_BindContext) { m_BindFile(rhs.m_BindFile), m_BindContext(rhs.m_BindContext) {
// copy buffer // copy buffer
if (rhs.m_pData != nullptr) { if (rhs.m_pData != nullptr) {
this->m_pData = new(std::nothrow) CKDWORD[rhs.m_DataDwSize]; this->m_pData = new CKDWORD[rhs.m_DataDwSize];
if (this->m_pData != nullptr) {
std::memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize); std::memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize);
}
} }
} }
CKStateChunk::CKStateChunk(CKStateChunk&& rhs) :
m_ClassId(rhs.m_ClassId), m_DataVersion(rhs.m_DataVersion), m_ChunkVersion(rhs.m_ChunkVersion),
m_Parser(rhs.m_Parser),
m_ObjectList(std::move(rhs.m_ObjectList)), m_ManagerList(std::move(rhs.m_ManagerList)), m_ChunkList(std::move(rhs.m_ChunkList)),
m_pData(rhs.m_pData), m_DataDwSize(rhs.m_DataDwSize),
m_BindFile(rhs.m_BindFile), m_BindContext(rhs.m_BindContext) {
// set to null after steal data
rhs.m_pData = nullptr;
// and clear it
rhs.Clear();
}
CKStateChunk& CKStateChunk::operator=(const CKStateChunk& rhs) { CKStateChunk& CKStateChunk::operator=(const CKStateChunk& rhs) {
this->Clear(); this->Clear();
@ -56,15 +66,41 @@ namespace LibCmo::CK2 {
// copy buffer // copy buffer
if (rhs.m_pData != nullptr) { if (rhs.m_pData != nullptr) {
this->m_pData = new(std::nothrow) CKDWORD[rhs.m_DataDwSize]; this->m_pData = new CKDWORD[rhs.m_DataDwSize];
if (this->m_pData != nullptr) {
std::memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize); std::memcpy(this->m_pData, rhs.m_pData, sizeof(CKDWORD) * rhs.m_DataDwSize);
}
} }
this->m_DataDwSize = rhs.m_DataDwSize; this->m_DataDwSize = rhs.m_DataDwSize;
return *this; return *this;
} }
CKStateChunk& CKStateChunk::operator=(CKStateChunk&& rhs) {
this->Clear();
this->m_DataVersion = rhs.m_DataVersion;
this->m_ChunkVersion = rhs.m_ChunkVersion;
this->m_ClassId = rhs.m_ClassId;
this->m_Parser = rhs.m_Parser;
this->m_ObjectList = rhs.m_ObjectList;
this->m_ManagerList = rhs.m_ManagerList;
this->m_ChunkList = rhs.m_ChunkList;
this->m_BindFile = rhs.m_BindFile;
this->m_BindContext = rhs.m_BindContext;
// steal buffer
this->m_pData = rhs.m_pData;
rhs.m_pData = nullptr;
this->m_DataDwSize = rhs.m_DataDwSize;
// clear steal chunk
rhs.Clear();
return *this;
}
CKStateChunk::~CKStateChunk() { CKStateChunk::~CKStateChunk() {
if (this->m_pData != nullptr) if (this->m_pData != nullptr)
delete[] this->m_pData; delete[] this->m_pData;
@ -79,6 +115,7 @@ namespace LibCmo::CK2 {
this->m_DataVersion = CK_STATECHUNK_DATAVERSION::CHUNK_DEV_2_1; this->m_DataVersion = CK_STATECHUNK_DATAVERSION::CHUNK_DEV_2_1;
this->m_ChunkVersion = CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION4; this->m_ChunkVersion = CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION4;
this->m_Parser.m_Status = CKStateChunkStatus::IDLE;
this->m_Parser.m_CurrentPos = 0; this->m_Parser.m_CurrentPos = 0;
this->m_Parser.m_DataSize = 0; this->m_Parser.m_DataSize = 0;
this->m_Parser.m_PrevIdentifierPos = 0; this->m_Parser.m_PrevIdentifierPos = 0;
@ -148,8 +185,7 @@ namespace LibCmo::CK2 {
} }
} else { } else {
// otherwise, we create a new buffer instead it // otherwise, we create a new buffer instead it
CKDWORD* newbuf = new(std::nothrow) CKDWORD[new_dwsize]; CKDWORD* newbuf = new CKDWORD[new_dwsize];
if (newbuf == nullptr) return false; // if fail to create, return
// if no original data, we do not need copy it and free it // if no original data, we do not need copy it and free it
if (this->m_pData != nullptr) { if (this->m_pData != nullptr) {
@ -221,9 +257,7 @@ namespace LibCmo::CK2 {
bufpos = 6u; bufpos = 6u;
if (this->m_DataDwSize != 0) { if (this->m_DataDwSize != 0) {
this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize]; this->m_pData = new CKDWORD[this->m_DataDwSize];
if (m_pData == nullptr) return false;
std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize); std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
bufpos += this->m_DataDwSize; bufpos += this->m_DataDwSize;
} }
@ -248,9 +282,7 @@ namespace LibCmo::CK2 {
bufpos = 7u; bufpos = 7u;
if (this->m_DataDwSize != 0) { if (this->m_DataDwSize != 0) {
this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize]; this->m_pData = new CKDWORD[this->m_DataDwSize];
if (m_pData == nullptr) return false;
std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize); std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
bufpos += this->m_DataDwSize; bufpos += this->m_DataDwSize;
} }
@ -285,9 +317,7 @@ namespace LibCmo::CK2 {
bufpos = 2u; bufpos = 2u;
if (this->m_DataDwSize != 0) { if (this->m_DataDwSize != 0) {
this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize]; this->m_pData = new CKDWORD[this->m_DataDwSize];
if (m_pData == nullptr) return false;
std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize); std::memcpy(this->m_pData, dwbuf + bufpos, sizeof(CKDWORD) * this->m_DataDwSize);
bufpos += this->m_DataDwSize; bufpos += this->m_DataDwSize;
} }
@ -335,8 +365,7 @@ namespace LibCmo::CK2 {
// // dwSize store the length of compressed buffer as CHAR size, not DWORD size! // // dwSize store the length of compressed buffer as CHAR size, not DWORD size!
// // create a enough buffer // // create a enough buffer
// char* buffer = new(std::nothrow) char[DestSize]; // char* buffer = new char[DestSize];
// if (buffer == nullptr) return false;
// uLongf destSize = DestSize; // uLongf destSize = DestSize;
// // uncompress it // // uncompress it
// auto err = uncompress( // auto err = uncompress(
@ -350,10 +379,8 @@ namespace LibCmo::CK2 {
// delete[] this->m_pData; // delete[] this->m_pData;
// this->m_pData = nullptr; // this->m_pData = nullptr;
// this->m_pData = new(std::nothrow) CKDWORD[this->m_DataDwSize]; // this->m_pData = new CKDWORD[this->m_DataDwSize];
// if (this->m_pData != nullptr) {
// std::memcpy(this->m_pData, buffer, this->m_DataDwSize * sizeof(CKDWORD)); // std::memcpy(this->m_pData, buffer, this->m_DataDwSize * sizeof(CKDWORD));
// }
// } // }
// delete[] buffer; // delete[] buffer;
// return true; // return true;
@ -509,8 +536,7 @@ namespace LibCmo::CK2 {
if (!this->EnsureReadSpace(subChunkSize)) goto subchunk_defer; if (!this->EnsureReadSpace(subChunkSize)) goto subchunk_defer;
// create statechunk // create statechunk
subchunk = new(std::nothrow) CKStateChunk(this->m_BindFile, this->m_BindContext); subchunk = new CKStateChunk(this->m_BindFile, this->m_BindContext);
if (subchunk == nullptr) goto subchunk_defer;
// start read data // start read data
// read class id // read class id
@ -528,8 +554,7 @@ namespace LibCmo::CK2 {
// read data size and create it // read data size and create it
if (!this->ReadStruct(subchunk->m_DataDwSize)) goto subchunk_defer; if (!this->ReadStruct(subchunk->m_DataDwSize)) goto subchunk_defer;
subchunk->m_pData = new(std::nothrow) CKDWORD[subchunk->m_DataDwSize]; subchunk->m_pData = new CKDWORD[subchunk->m_DataDwSize];
if (subchunk->m_pData == nullptr) goto subchunk_defer;
// has bind file? // has bind file?
CKDWORD hasBindFile; CKDWORD hasBindFile;
@ -578,8 +603,7 @@ namespace LibCmo::CK2 {
// read data size and create it // read data size and create it
if (!this->ReadStruct(subchunk->m_DataDwSize)) goto subchunk_defer; if (!this->ReadStruct(subchunk->m_DataDwSize)) goto subchunk_defer;
subchunk->m_pData = new(std::nothrow) CKDWORD[subchunk->m_DataDwSize]; subchunk->m_pData = new CKDWORD[subchunk->m_DataDwSize];
if (subchunk->m_pData == nullptr) goto subchunk_defer;
// skip one? // skip one?
// I don't know why // I don't know why
@ -616,11 +640,7 @@ namespace LibCmo::CK2 {
*len_in_byte = bufByteSize; *len_in_byte = bufByteSize;
// create buffer // create buffer
*buf = new(std::nothrow) char[bufByteSize]; *buf = new char[bufByteSize];
if (*buf == nullptr) {
*len_in_byte = 0;
return false;
}
// read data // read data
if (!this->ReadByteData(*buf, bufByteSize)) { if (!this->ReadByteData(*buf, bufByteSize)) {
@ -718,7 +738,7 @@ namespace LibCmo::CK2 {
CKDWORD count; CKDWORD count;
if (!this->ReadStruct(count)) return false; if (!this->ReadStruct(count)) return false;
if (!count) return true; // 0 size array if (!count) return true; // 0 size array
// old file size correction // old file size correction
if (this->m_ChunkVersion < CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION1) { if (this->m_ChunkVersion < CK_STATECHUNK_CHUNKVERSION::CHUNK_VERSION1) {
// skip 4. but I don't know why!!! // skip 4. but I don't know why!!!

15
LibCmo/CK2/CKStateChunk.hpp
View File

@ -11,7 +11,7 @@ namespace LibCmo::CK2 {
CKStateChunk(const CKStateChunk&); CKStateChunk(const CKStateChunk&);
CKStateChunk(CKStateChunk&&); CKStateChunk(CKStateChunk&&);
CKStateChunk& operator=(const CKStateChunk&); CKStateChunk& operator=(const CKStateChunk&);
CKStateChunk& operator-(const CKStateChunk&&); CKStateChunk& operator=(CKStateChunk&&);
~CKStateChunk(); ~CKStateChunk();
private: private:
@ -20,6 +20,12 @@ namespace LibCmo::CK2 {
READ, READ,
WRITE WRITE
}; };
struct ChunkParser {
CKStateChunkStatus m_Status;
CKDWORD m_CurrentPos;
CKDWORD m_DataSize;
CKDWORD m_PrevIdentifierPos;
};
CK_CLASSID m_ClassId; CK_CLASSID m_ClassId;
CKDWORD m_DataDwSize; CKDWORD m_DataDwSize;
@ -28,12 +34,7 @@ namespace LibCmo::CK2 {
CK_STATECHUNK_DATAVERSION m_DataVersion; CK_STATECHUNK_DATAVERSION m_DataVersion;
CK_STATECHUNK_CHUNKVERSION m_ChunkVersion; CK_STATECHUNK_CHUNKVERSION m_ChunkVersion;
struct { ChunkParser m_Parser;
CKStateChunkStatus m_Status;
CKDWORD m_CurrentPos;
CKDWORD m_DataSize;
CKDWORD m_PrevIdentifierPos;
}m_Parser;
std::vector<CKDWORD> m_ObjectList; std::vector<CKDWORD> m_ObjectList;
std::vector<CKDWORD> m_ChunkList; std::vector<CKDWORD> m_ChunkList;

134
LibCmo/CK2/CKTypes.hpp
View File

@ -191,87 +191,91 @@ namespace LibCmo::CK2 {
// ========== Class List ========== // ========== Class List ==========
// Objects and derivated classes // Objects and derivated classes
class CKObject; namespace ObjImpls {
class CKInterfaceObjectManager; class CKObject;
class CKRenderContext; class CKInterfaceObjectManager;
class CKParameterIn; class CKRenderContext;
class CKParameter; class CKParameterIn;
class CKParameterOut; class CKParameter;
class CKParameterLocal; class CKParameterOut;
class CKParameterOperation; class CKParameterLocal;
class CKBehaviorLink; class CKParameterOperation;
class CKBehaviorIO; class CKBehaviorLink;
class CKRenderContext; class CKBehaviorIO;
class CKSynchroObject; class CKRenderContext;
class CKStateObject; class CKSynchroObject;
class CKCriticalSectionObject; class CKStateObject;
class CKKinematicChain; class CKCriticalSectionObject;
class CKObjectAnimation; class CKKinematicChain;
class CKLayer; class CKObjectAnimation;
class CKSceneObject; class CKLayer;
class CKBehavior; class CKSceneObject;
class CKAnimation; class CKBehavior;
class CKKeyedAnimation; class CKAnimation;
class CKBeObject; class CKKeyedAnimation;
class CKScene; class CKBeObject;
class CKLevel; class CKScene;
class CKPlace; class CKLevel;
class CKGroup; class CKPlace;
class CKMaterial; class CKGroup;
class CKTexture; class CKMaterial;
class CKMesh; class CKTexture;
class CKPatchMesh; class CKMesh;
class CKProgressiveMesh; class CKPatchMesh;
class CKDataArray; class CKProgressiveMesh;
class CKSound; class CKDataArray;
class CKMidiSound; class CKSound;
class CKWaveSound; class CKMidiSound;
class CKRenderObject; class CKWaveSound;
class CK2dEntity; class CKRenderObject;
class CKSprite; class CK2dEntity;
class CKSpriteText; class CKSprite;
class CK3dEntity; class CKSpriteText;
class CKCamera; class CK3dEntity;
class CKTargetCamera; class CKCamera;
class CKCurvePoint; class CKTargetCamera;
class CKSprite3D; class CKCurvePoint;
class CKLight; class CKSprite3D;
class CKTargetLight; class CKLight;
class CKCharacter; class CKTargetLight;
class CK3dObject; class CKCharacter;
class CKBodyPart; class CK3dObject;
class CKCurve; class CKBodyPart;
class CKGrid; class CKCurve;
class CKGrid;
}
//---- Misc //---- Misc
class CKBehaviorPrototype; class CKBehaviorPrototype;
class CKMessage; class CKMessage;
class CK2dCurvePoint; class CK2dCurvePoint;
class CK2dCurve; class CK2dCurve;
class CKStateChunk; //class CKStateChunk;
class CKFile; //class CKFile;
class CKDependencies; class CKDependencies;
class CKDependenciesContext; class CKDependenciesContext;
class CKPluginManager; class CKPluginManager;
class CKDebugContext; class CKDebugContext;
class CKObjectArray; class CKObjectArray;
class CKObjectDeclaration; class CKObjectDeclaration;
class CKContext; //class CKContext;
struct CKBitmapProperties; struct CKBitmapProperties;
class CKVertexBuffer; class CKVertexBuffer;
//--- Managers //--- Managers
class CKBaseManager; namespace MgrImpls {
class CKSoundManager; class CKBaseManager;
class CKTimeManager; class CKSoundManager;
class CKRenderManager; class CKTimeManager;
class CKBehaviorManager; class CKRenderManager;
class CKMessageManager; class CKBehaviorManager;
class CKParameterManager; class CKMessageManager;
class CKAttributeManager; class CKParameterManager;
class CKPathManager; class CKAttributeManager;
class CKVariableManager; class CKPathManager;
class CKSceneObjectDesc; class CKVariableManager;
class CKSceneObjectDesc;
}
//--- Important classes //--- Important classes
class CKContext; class CKContext;

2
LibCmo/CK2/CKManagerImplements/CKBaseManager.cpp → LibCmo/CK2/MgrImpls/CKBaseManager.cpp
View File

@ -1,6 +1,6 @@
#include "CKBaseManager.hpp" #include "CKBaseManager.hpp"
namespace LibCmo::CK2 { namespace LibCmo::CK2::MgrImpls {
// todo: this file maybe not used anymore. if more manager added. i think this file can be removed. // todo: this file maybe not used anymore. if more manager added. i think this file can be removed.
//CKERROR CKBaseManager::LoadData(CKStateChunk* statechunk, CKFileDocument* doc) { //CKERROR CKBaseManager::LoadData(CKStateChunk* statechunk, CKFileDocument* doc) {

2
LibCmo/CK2/CKManagerImplements/CKBaseManager.hpp → LibCmo/CK2/MgrImpls/CKBaseManager.hpp
View File

@ -2,7 +2,7 @@
#include "../../VTAll.hpp" #include "../../VTAll.hpp"
namespace LibCmo::CK2 { namespace LibCmo::CK2::MgrImpls {
/** /**
@brief Base Class for managers. @brief Base Class for managers.

2
LibCmo/CK2/CKObjectImplements/CKObject.cpp → LibCmo/CK2/ObjImpls/CKObject.cpp
View File

@ -1,7 +1,7 @@
#include "CKObject.hpp" #include "CKObject.hpp"
#include "../CKStateChunk.hpp" #include "../CKStateChunk.hpp"
namespace LibCmo::CK2 { namespace LibCmo::CK2::ObjImpls {
void CKObject::PreSave(CKFileVisitor* file, CKDWORD flags) {} void CKObject::PreSave(CKFileVisitor* file, CKDWORD flags) {}

2
LibCmo/CK2/CKObjectImplements/CKObject.hpp → LibCmo/CK2/ObjImpls/CKObject.hpp
View File

@ -3,7 +3,7 @@
#include "../../VTUtils.hpp" #include "../../VTUtils.hpp"
#include "../CKContext.hpp" #include "../CKContext.hpp"
namespace LibCmo::CK2 { namespace LibCmo::CK2::ObjImpls {
class CKObject { class CKObject {
public: public:

8
LibCmo/LibCmo.vcxproj
View File

@ -178,9 +178,9 @@
<ClCompile Include="CK2\CKFileOthers.cpp" /> <ClCompile Include="CK2\CKFileOthers.cpp" />
<ClCompile Include="CK2\CKFileWriter.cpp" /> <ClCompile Include="CK2\CKFileWriter.cpp" />
<ClCompile Include="CK2\CKGlobals.cpp" /> <ClCompile Include="CK2\CKGlobals.cpp" />
<ClCompile Include="CK2\CKManagerImplements\CKBaseManager.cpp" /> <ClCompile Include="CK2\MgrImpls\CKBaseManager.cpp" />
<ClCompile Include="CK2\CKContext.cpp" /> <ClCompile Include="CK2\CKContext.cpp" />
<ClCompile Include="CK2\CKObjectImplements\CKObject.cpp" /> <ClCompile Include="CK2\ObjImpls\CKObject.cpp" />
<ClCompile Include="VTEncoding.cpp" /> <ClCompile Include="VTEncoding.cpp" />
<ClCompile Include="CK2\CKFileReader.cpp" /> <ClCompile Include="CK2\CKFileReader.cpp" />
<ClCompile Include="CK2\CKStateChunk.cpp" /> <ClCompile Include="CK2\CKStateChunk.cpp" />
@ -193,13 +193,13 @@
<ClInclude Include="CK2\CKFile.hpp" /> <ClInclude Include="CK2\CKFile.hpp" />
<ClInclude Include="CK2\CKGlobals.hpp" /> <ClInclude Include="CK2\CKGlobals.hpp" />
<ClInclude Include="CK2\CKIdentifiers.hpp" /> <ClInclude Include="CK2\CKIdentifiers.hpp" />
<ClInclude Include="CK2\CKManagerImplements\CKBaseManager.hpp" /> <ClInclude Include="CK2\MgrImpls\CKBaseManager.hpp" />
<ClInclude Include="CK2\CKContext.hpp" /> <ClInclude Include="CK2\CKContext.hpp" />
<ClInclude Include="CK2\CKStateChunk.hpp" /> <ClInclude Include="CK2\CKStateChunk.hpp" />
<ClInclude Include="CK2\CKTypes.hpp" /> <ClInclude Include="CK2\CKTypes.hpp" />
<ClInclude Include="VTAll.hpp" /> <ClInclude Include="VTAll.hpp" />
<ClInclude Include="VTEncoding.hpp" /> <ClInclude Include="VTEncoding.hpp" />
<ClInclude Include="CK2\CKObjectImplements\CKObject.hpp" /> <ClInclude Include="CK2\ObjImpls\CKObject.hpp" />
<ClInclude Include="VTUtils.hpp" /> <ClInclude Include="VTUtils.hpp" />
<ClInclude Include="VxMath\VxMemoryMappedFile.hpp" /> <ClInclude Include="VxMath\VxMemoryMappedFile.hpp" />
<ClInclude Include="VxMath\VxTypes.hpp" /> <ClInclude Include="VxMath\VxTypes.hpp" />

24
LibCmo/LibCmo.vcxproj.filters
View File

@ -31,16 +31,16 @@
<Filter Include="Sources\XContainer"> <Filter Include="Sources\XContainer">
<UniqueIdentifier>{3dee80b5-d27a-4071-9194-3c817ba38c4c}</UniqueIdentifier> <UniqueIdentifier>{3dee80b5-d27a-4071-9194-3c817ba38c4c}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="Headers\CK2\CKManagerImplements"> <Filter Include="Headers\CK2\MgrImpls">
<UniqueIdentifier>{bc2c80b7-8622-41f4-9bef-480a71430eb8}</UniqueIdentifier> <UniqueIdentifier>{bc2c80b7-8622-41f4-9bef-480a71430eb8}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="Headers\CK2\CKObjectImplements"> <Filter Include="Headers\CK2\ObjImpls">
<UniqueIdentifier>{9bec41df-78db-4753-ab80-86345545227d}</UniqueIdentifier> <UniqueIdentifier>{9bec41df-78db-4753-ab80-86345545227d}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="Sources\CK2\CKManagerImplements"> <Filter Include="Sources\CK2\MgrImpls">
<UniqueIdentifier>{784282d9-4adb-40ca-bbac-902c74e9a2e5}</UniqueIdentifier> <UniqueIdentifier>{784282d9-4adb-40ca-bbac-902c74e9a2e5}</UniqueIdentifier>
</Filter> </Filter>
<Filter Include="Sources\CK2\CKObjectImplements"> <Filter Include="Sources\CK2\ObjImpls">
<UniqueIdentifier>{a8cd2188-b552-478c-9801-a6286b3d48a0}</UniqueIdentifier> <UniqueIdentifier>{a8cd2188-b552-478c-9801-a6286b3d48a0}</UniqueIdentifier>
</Filter> </Filter>
</ItemGroup> </ItemGroup>
@ -48,14 +48,14 @@
<ClCompile Include="VTEncoding.cpp"> <ClCompile Include="VTEncoding.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="CK2\CKObjectImplements\CKObject.cpp"> <ClCompile Include="CK2\ObjImpls\CKObject.cpp">
<Filter>Sources\CK2\CKObjectImplements</Filter> <Filter>Sources\CK2\ObjImpls</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="VTUtils.cpp"> <ClCompile Include="VTUtils.cpp">
<Filter>Sources</Filter> <Filter>Sources</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="CK2\CKManagerImplements\CKBaseManager.cpp"> <ClCompile Include="CK2\MgrImpls\CKBaseManager.cpp">
<Filter>Sources\CK2\CKManagerImplements</Filter> <Filter>Sources\CK2\MgrImpls</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="VxMath\VxMemoryMappedFile.cpp"> <ClCompile Include="VxMath\VxMemoryMappedFile.cpp">
<Filter>Sources\VxMath</Filter> <Filter>Sources\VxMath</Filter>
@ -122,11 +122,11 @@
<ClInclude Include="VTAll.hpp"> <ClInclude Include="VTAll.hpp">
<Filter>Headers</Filter> <Filter>Headers</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="CK2\CKManagerImplements\CKBaseManager.hpp"> <ClInclude Include="CK2\MgrImpls\CKBaseManager.hpp">
<Filter>Headers\CK2\CKObjectImplements</Filter> <Filter>Headers\CK2\ObjImpls</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="CK2\CKObjectImplements\CKObject.hpp"> <ClInclude Include="CK2\ObjImpls\CKObject.hpp">
<Filter>Headers\CK2\CKManagerImplements</Filter> <Filter>Headers\CK2\MgrImpls</Filter>
</ClInclude> </ClInclude>
</ItemGroup> </ItemGroup>
</Project> </Project>

8
LibCmo/VTEncoding.cpp
View File

@ -156,9 +156,7 @@ namespace LibCmo::EncodingHelper {
#if defined(LIBCMO_OS_WIN32) #if defined(LIBCMO_OS_WIN32)
ENCODING_TOKEN CreateEncodingToken(const std::string& token_string) { ENCODING_TOKEN CreateEncodingToken(const std::string& token_string) {
ENCODING_TOKEN token = new(std::nothrow) UINT(); ENCODING_TOKEN token = new UINT();
if (token == nullptr) return ENCODING_TOKEN_DEFAULT;
if (!GetWindowsCodePage(token_string.c_str(), token)) { if (!GetWindowsCodePage(token_string.c_str(), token)) {
*token = CP_ACP; *token = CP_ACP;
} }
@ -209,9 +207,7 @@ namespace LibCmo::EncodingHelper {
static constexpr const char UTF8_SYMBOL[] = "UTF-8"; static constexpr const char UTF8_SYMBOL[] = "UTF-8";
ENCODING_TOKEN CreateEncodingToken(const std::string& token_string) { ENCODING_TOKEN CreateEncodingToken(const std::string& token_string) {
ENCODING_TOKEN token = new(std::nothrow) IconvPair(); ENCODING_TOKEN token = new IconvPair();
if (token == nullptr) return ENCODING_TOKEN_DEFAULT;
if (!CreateIconvDescriptor(UTF8_SYMBOL, token_string.c_str(), token->FromUtf8) || if (!CreateIconvDescriptor(UTF8_SYMBOL, token_string.c_str(), token->FromUtf8) ||
!CreateIconvDescriptor(token_string.c_str(), UTF8_SYMBOL, token->ToUtf8)) { !CreateIconvDescriptor(token_string.c_str(), UTF8_SYMBOL, token->ToUtf8)) {
delete token; delete token;

2
LibCmo/XContainer/XTypes.hpp
View File

@ -55,7 +55,7 @@ namespace LibCmo::XContainer {
@todo May independ this class to implement the functions introduced in remarks. @todo May independ this class to implement the functions introduced in remarks.
@see XObjectArray, CKObjectArray @see XObjectArray, CKObjectArray
*/ */
using XObjectPointerArray = XArray<CK2::CKObject*>; using XObjectPointerArray = XArray<CK2::ObjImpls::CKObject*>;
/** /**
@brief Class representation of an Hash Table container. @brief Class representation of an Hash Table container.