zone/OpenAssetTools
zone/OpenAssetTools
2
0
Fork 0
mirror of https://github.com/Laupetin/OpenAssetTools.git synced 2025-05-07 13:04:58 +00:00
Code Issues Packages Projects Wiki Activity

refactor: adjust template const modifiers

Browse Source
This commit is contained in:
Jan 2025-05-02 12:37:23 +01:00
parent 8b85cadb77
commit ed029bc24d
No known key found for this signature in database
GPG Key ID: 44B581F78FF5C57C
13 changed files with 70 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
src/ZoneCodeGeneratorLib/Generating/CodeGenerator.cpp
View File

@ -27,7 +27,7 @@ void CodeGenerator::SetupTemplates()
m_template_mapping["assetstructtests"] = std::make_unique<AssetStructTestsTemplate>(); m_template_mapping["assetstructtests"] = std::make_unique<AssetStructTestsTemplate>();
} }
bool CodeGenerator::GenerateCodeForTemplate(RenderingContext* context, ICodeTemplate* codeTemplate) const bool CodeGenerator::GenerateCodeForTemplate(const RenderingContext& context, ICodeTemplate* codeTemplate) const
{ {
for (const auto& codeFile : codeTemplate->GetFilesToRender(context)) for (const auto& codeFile : codeTemplate->GetFilesToRender(context))
{ {
@ -110,7 +110,7 @@ bool CodeGenerator::GenerateCode(IDataRepository* repository)
for (auto* asset : assets) for (auto* asset : assets)
{ {
auto context = RenderingContext::BuildContext(repository, asset); auto context = RenderingContext::BuildContext(repository, asset);
if (!GenerateCodeForTemplate(context.get(), foundTemplate->second.get())) if (!GenerateCodeForTemplate(*context, foundTemplate->second.get()))
{ {
std::cerr << std::format( std::cerr << std::format(
"Failed to generate code for asset '{}' with preset '{}'\n", asset->m_definition->GetFullName(), foundTemplate->first); "Failed to generate code for asset '{}' with preset '{}'\n", asset->m_definition->GetFullName(), foundTemplate->first);
@ -128,7 +128,7 @@ bool CodeGenerator::GenerateCode(IDataRepository* repository)
return false; return false;
auto context = RenderingContext::BuildContext(repository, asset); auto context = RenderingContext::BuildContext(repository, asset);
if (!GenerateCodeForTemplate(context.get(), foundTemplate->second.get())) if (!GenerateCodeForTemplate(*context, foundTemplate->second.get()))
return false; return false;
} }
} }

2
src/ZoneCodeGeneratorLib/Generating/CodeGenerator.h
View File

@ -17,7 +17,7 @@ public:
private: private:
void SetupTemplates(); void SetupTemplates();
bool GenerateCodeForTemplate(RenderingContext* context, ICodeTemplate* codeTemplate) const; bool GenerateCodeForTemplate(const RenderingContext& context, ICodeTemplate* codeTemplate) const;
static bool GetAssetWithName(IDataRepository* repository, const std::string& name, StructureInformation*& asset); static bool GetAssetWithName(IDataRepository* repository, const std::string& name, StructureInformation*& asset);
const ZoneCodeGeneratorArguments* m_args; const ZoneCodeGeneratorArguments* m_args;

4
src/ZoneCodeGeneratorLib/Generating/ICodeTemplate.h
View File

@ -29,6 +29,6 @@ public:
ICodeTemplate& operator=(const ICodeTemplate& other) = default; ICodeTemplate& operator=(const ICodeTemplate& other) = default;
ICodeTemplate& operator=(ICodeTemplate&& other) noexcept = default; ICodeTemplate& operator=(ICodeTemplate&& other) noexcept = default;
virtual std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) = 0; virtual std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) = 0;
virtual void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) = 0; virtual void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) = 0;
}; };

51
src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.cpp
View File

@ -2,18 +2,19 @@
#include "Domain/Computations/StructureComputations.h" #include "Domain/Computations/StructureComputations.h"
#include "Internal/BaseTemplate.h" #include "Internal/BaseTemplate.h"
#include "Utils/StringUtils.h"
#include <iostream> #include <cassert>
#include <sstream> #include <format>
namespace namespace
{ {
static constexpr int TAG_SOURCE = 1; constexpr int TAG_SOURCE = 1;
class Template final : BaseTemplate class Template final : BaseTemplate
{ {
public: public:
Template(std::ostream& stream, RenderingContext* context) Template(std::ostream& stream, const RenderingContext& context)
: BaseTemplate(stream, context) : BaseTemplate(stream, context)
{ {
} }
@ -26,21 +27,22 @@ namespace
LINE("// Any changes will be discarded when regenerating.") LINE("// Any changes will be discarded when regenerating.")
LINE("// ====================================================================") LINE("// ====================================================================")
LINE("") LINE("")
LINEF("#include \"Game/{0}/{0}.h\"", m_env.m_game)
LINE("")
LINE("#include <catch2/catch_test_macros.hpp>") LINE("#include <catch2/catch_test_macros.hpp>")
LINE("#include <catch2/generators/catch_generators.hpp>") LINE("#include <catch2/generators/catch_generators.hpp>")
LINE("#include <cstddef>") LINE("#include <cstddef>")
LINE("#include \"Game/" << m_env.m_game << "/" << m_env.m_game << ".h\"")
LINE("") LINE("")
LINE("using namespace " << m_env.m_game << ";") LINEF("using namespace {0};", m_env.m_game)
LINE("") LINE("")
LINE("namespace game::" << m_env.m_game << "::xassets::asset_" << Lower(m_env.m_asset->m_definition->m_name)) LINEF("namespace game::{0}::xassets::asset_{1}", m_env.m_game, Lower(m_env.m_asset->m_definition->m_name))
LINE("{") LINE("{")
m_intendation++; m_intendation++;
if (m_env.m_asset->m_has_matching_cross_platform_structure) if (m_env.m_asset->m_has_matching_cross_platform_structure)
TestMethod(m_env.m_asset); TestMethod(m_env.m_asset);
for (auto* structure : m_env.m_used_structures) for (const auto* structure : m_env.m_used_structures)
{ {
StructureComputations computations(structure->m_info); StructureComputations computations(structure->m_info);
if (!structure->m_info->m_definition->m_anonymous && !computations.IsAsset() && structure->m_info->m_has_matching_cross_platform_structure) if (!structure->m_info->m_definition->m_anonymous && !computations.IsAsset() && structure->m_info->m_has_matching_cross_platform_structure)
@ -52,10 +54,12 @@ namespace
} }
private: private:
void TestMethod(StructureInformation* structure) void TestMethod(const StructureInformation* structure)
{ {
LINE("TEST_CASE(\"" << m_env.m_game << "::" << m_env.m_asset->m_definition->GetFullName() << ": Tests for " LINEF("TEST_CASE(\"{0}::{1}: Tests for {2}\", \"[assetstruct]\")",
<< structure->m_definition->GetFullName() << "\", \"[assetstruct]\")") m_env.m_game,
m_env.m_asset->m_definition->GetFullName(),
structure->m_definition->GetFullName())
LINE("{") LINE("{")
m_intendation++; m_intendation++;
@ -63,44 +67,37 @@ namespace
{ {
if (!member->m_member->m_name.empty() && !member->m_member->m_type_declaration->m_has_custom_bit_size) if (!member->m_member->m_name.empty() && !member->m_member->m_type_declaration->m_has_custom_bit_size)
{ {
LINE("REQUIRE(offsetof(" << structure->m_definition->GetFullName() << ", " << member->m_member->m_name LINEF("REQUIRE(offsetof({0}, {1}) == {2});", structure->m_definition->GetFullName(), member->m_member->m_name, member->m_member->m_offset)
<< ") == " << member->m_member->m_offset << ");")
} }
} }
LINE("") LINE("")
LINE("REQUIRE(" << structure->m_definition->GetSize() << "u == sizeof(" << structure->m_definition->GetFullName() << "));") LINEF("REQUIRE({0}u == sizeof({1}));", structure->m_definition->GetSize(), structure->m_definition->GetFullName())
LINE("REQUIRE(" << structure->m_definition->GetAlignment() << "u == alignof(" << structure->m_definition->GetFullName() << "));") LINEF("REQUIRE({0}u == alignof({1}));", structure->m_definition->GetAlignment(), structure->m_definition->GetFullName())
m_intendation--; m_intendation--;
LINE("}") LINE("}")
} }
}; };
} // namespace } // namespace
std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(RenderingContext* context) std::vector<CodeTemplateFile> AssetStructTestsTemplate::GetFilesToRender(const RenderingContext& context)
{ {
std::vector<CodeTemplateFile> files; std::vector<CodeTemplateFile> files;
auto assetName = context->m_asset->m_definition->m_name; auto assetName = context.m_asset->m_definition->m_name;
for (auto& c : assetName) utils::MakeStringLowerCase(assetName);
c = static_cast<char>(tolower(c));
{ files.emplace_back(std::format("{0}/{0}_struct_test.cpp", assetName), TAG_SOURCE);
std::ostringstream str;
str << assetName << '/' << assetName << "_struct_test.cpp";
files.emplace_back(str.str(), TAG_SOURCE);
}
return files; return files;
} }
void AssetStructTestsTemplate::RenderFile(std::ostream& stream, const int fileTag, RenderingContext* context) void AssetStructTestsTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
{ {
Template t(stream, context); Template t(stream, context);
assert(fileTag == TAG_SOURCE);
if (fileTag == TAG_SOURCE) if (fileTag == TAG_SOURCE)
t.Source(); t.Source();
else
std::cout << "Invalid tag in AssetStructTestsTemplate\n";
} }

4
src/ZoneCodeGeneratorLib/Generating/Templates/AssetStructTestsTemplate.h
View File

@ -4,6 +4,6 @@
class AssetStructTestsTemplate final : public ICodeTemplate class AssetStructTestsTemplate final : public ICodeTemplate
{ {
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
}; };

4
src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.cpp
View File

@ -5,9 +5,9 @@
#include <sstream> #include <sstream>
BaseTemplate::BaseTemplate(std::ostream& stream, RenderingContext* context) BaseTemplate::BaseTemplate(std::ostream& stream, const RenderingContext& context)
: m_out(stream), : m_out(stream),
m_env(*context), m_env(context),
m_intendation(0u) m_intendation(0u)
{ {
} }

4
src/ZoneCodeGeneratorLib/Generating/Templates/Internal/BaseTemplate.h
View File

@ -15,7 +15,7 @@ class BaseTemplate
protected: protected:
static constexpr auto INTENDATION = " "; static constexpr auto INTENDATION = " ";
BaseTemplate(std::ostream& stream, RenderingContext* context); BaseTemplate(std::ostream& stream, const RenderingContext& context);
void DoIntendation() const; void DoIntendation() const;
@ -41,7 +41,7 @@ protected:
static std::string MakeEvaluation(const IEvaluation* evaluation); static std::string MakeEvaluation(const IEvaluation* evaluation);
std::ostream& m_out; std::ostream& m_out;
RenderingContext& m_env; const RenderingContext& m_env;
unsigned m_intendation; unsigned m_intendation;
private: private:

26
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.cpp
View File

@ -16,7 +16,7 @@ namespace
class Template final : BaseTemplate class Template final : BaseTemplate
{ {
public: public:
Template(std::ostream& stream, RenderingContext* context) Template(std::ostream& stream, const RenderingContext& context)
: BaseTemplate(stream, context) : BaseTemplate(stream, context)
{ {
} }
@ -308,7 +308,7 @@ namespace
} }
} }
void PrintLoadPtrArrayMethod_PointerCheck(const DataDefinition* def, StructureInformation* info, const bool reusable) void PrintLoadPtrArrayMethod_PointerCheck(const DataDefinition* def, const StructureInformation* info, const bool reusable)
{ {
LINEF("if (*{0})", MakeTypePtrVarName(def)) LINEF("if (*{0})", MakeTypePtrVarName(def))
LINE("{") LINE("{")
@ -350,7 +350,7 @@ namespace
LINE("}") LINE("}")
} }
void PrintLoadPtrArrayMethod(const DataDefinition* def, StructureInformation* info, const bool reusable) void PrintLoadPtrArrayMethod(const DataDefinition* def, const StructureInformation* info, const bool reusable)
{ {
LINEF("void {0}::LoadPtrArray_{1}(const bool atStreamStart, const size_t count)", LoaderClassName(m_env.m_asset), MakeSafeTypeName(def)) LINEF("void {0}::LoadPtrArray_{1}(const bool atStreamStart, const size_t count)", LoaderClassName(m_env.m_asset), MakeSafeTypeName(def))
LINE("{") LINE("{")
@ -903,7 +903,7 @@ namespace
} }
} }
void LoadMember_ReferenceArray(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) void LoadMember_ReferenceArray(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier)
{ {
auto first = true; auto first = true;
for (const auto& entry : modifier.GetArrayEntries()) for (const auto& entry : modifier.GetArrayEntries())
@ -921,7 +921,7 @@ namespace
} }
} }
void LoadMember_Reference(StructureInformation* info, MemberInformation* member, const DeclarationModifierComputations& modifier) void LoadMember_Reference(const StructureInformation* info, const MemberInformation* member, const DeclarationModifierComputations& modifier)
{ {
if (modifier.IsDynamicArray()) if (modifier.IsDynamicArray())
{ {
@ -958,7 +958,7 @@ namespace
} }
} }
void LoadMember_Condition_Struct(StructureInformation* info, MemberInformation* member) void LoadMember_Condition_Struct(const StructureInformation* info, const MemberInformation* member)
{ {
LINE("") LINE("")
if (member->m_condition) if (member->m_condition)
@ -978,7 +978,7 @@ namespace
} }
} }
void LoadMember_Condition_Union(StructureInformation* info, MemberInformation* member) void LoadMember_Condition_Union(const StructureInformation* info, const MemberInformation* member)
{ {
const MemberComputations computations(member); const MemberComputations computations(member);
@ -1046,7 +1046,7 @@ namespace
} }
} }
void PrintLoadMemberIfNeedsTreatment(StructureInformation* info, MemberInformation* member) void PrintLoadMemberIfNeedsTreatment(const StructureInformation* info, const MemberInformation* member)
{ {
const MemberComputations computations(member); const MemberComputations computations(member);
if (computations.ShouldIgnore()) if (computations.ShouldIgnore())
@ -1062,7 +1062,7 @@ namespace
} }
} }
void PrintLoadMethod(StructureInformation* info) void PrintLoadMethod(const StructureInformation* info)
{ {
const StructureComputations computations(info); const StructureComputations computations(info);
LINEF("void {0}::Load_{1}(const bool atStreamStart)", LoaderClassName(m_env.m_asset), info->m_definition->m_name) LINEF("void {0}::Load_{1}(const bool atStreamStart)", LoaderClassName(m_env.m_asset), info->m_definition->m_name)
@ -1126,7 +1126,7 @@ namespace
LINE("}") LINE("}")
} }
void PrintLoadPtrMethod(StructureInformation* info) void PrintLoadPtrMethod(const StructureInformation* info)
{ {
const bool inTemp = info->m_block && info->m_block->m_type == FastFileBlockType::TEMP; const bool inTemp = info->m_block && info->m_block->m_type == FastFileBlockType::TEMP;
LINEF("void {0}::LoadPtr_{1}(const bool atStreamStart)", LoaderClassName(m_env.m_asset), MakeSafeTypeName(info->m_definition)) LINEF("void {0}::LoadPtr_{1}(const bool atStreamStart)", LoaderClassName(m_env.m_asset), MakeSafeTypeName(info->m_definition))
@ -1310,11 +1310,11 @@ namespace
}; };
} // namespace } // namespace
std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRender(RenderingContext* context) std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRender(const RenderingContext& context)
{ {
std::vector<CodeTemplateFile> files; std::vector<CodeTemplateFile> files;
auto assetName = context->m_asset->m_definition->m_name; auto assetName = context.m_asset->m_definition->m_name;
utils::MakeStringLowerCase(assetName); utils::MakeStringLowerCase(assetName);
files.emplace_back(std::format("{0}/{0}_load_db.h", assetName), TAG_HEADER); files.emplace_back(std::format("{0}/{0}_load_db.h", assetName), TAG_HEADER);
@ -1323,7 +1323,7 @@ std::vector<CodeTemplateFile> ZoneLoadTemplate::GetFilesToRender(RenderingContex
return files; return files;
} }
void ZoneLoadTemplate::RenderFile(std::ostream& stream, const int fileTag, RenderingContext* context) void ZoneLoadTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
{ {
Template t(stream, context); Template t(stream, context);

4
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneLoadTemplate.h
View File

@ -4,6 +4,6 @@
class ZoneLoadTemplate final : public ICodeTemplate class ZoneLoadTemplate final : public ICodeTemplate
{ {
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
}; };

18
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.cpp
View File

@ -6,7 +6,6 @@
#include "Utils/StringUtils.h" #include "Utils/StringUtils.h"
#include <cassert> #include <cassert>
#include <iostream>
#include <sstream> #include <sstream>
namespace namespace
@ -17,7 +16,7 @@ namespace
class Template final : BaseTemplate class Template final : BaseTemplate
{ {
public: public:
Template(std::ostream& stream, RenderingContext* context) Template(std::ostream& stream, const RenderingContext& context)
: BaseTemplate(stream, context) : BaseTemplate(stream, context)
{ {
} }
@ -276,7 +275,7 @@ namespace
} }
} }
void PrintMarkPtrArrayMethod_PointerCheck(const DataDefinition* def, StructureInformation* info, const bool reusable) void PrintMarkPtrArrayMethod_PointerCheck(const DataDefinition* def, const StructureInformation* info)
{ {
LINEF("if (*{0})", MakeTypePtrVarName(def)) LINEF("if (*{0})", MakeTypePtrVarName(def))
LINE("{") LINE("{")
@ -295,7 +294,7 @@ namespace
LINE("}") LINE("}")
} }
void PrintMarkPtrArrayMethod(const DataDefinition* def, StructureInformation* info, const bool reusable) void PrintMarkPtrArrayMethod(const DataDefinition* def, const StructureInformation* info, const bool reusable)
{ {
LINEF("void {0}::MarkPtrArray_{1}(const size_t count)", MarkerClassName(m_env.m_asset), MakeSafeTypeName(def)) LINEF("void {0}::MarkPtrArray_{1}(const size_t count)", MarkerClassName(m_env.m_asset), MakeSafeTypeName(def))
LINE("{") LINE("{")
@ -310,7 +309,7 @@ namespace
m_intendation++; m_intendation++;
LINEF("{0} = var;", MakeTypePtrVarName(def)) LINEF("{0} = var;", MakeTypePtrVarName(def))
PrintMarkPtrArrayMethod_PointerCheck(def, info, reusable); PrintMarkPtrArrayMethod_PointerCheck(def, info);
LINE("") LINE("")
LINE("var++;") LINE("var++;")
@ -531,7 +530,8 @@ namespace
} }
} }
static bool MarkMember_ShouldMakePointerCheck(const MemberInformation* member, const DeclarationModifierComputations& modifier, MemberLoadType loadType) static bool
MarkMember_ShouldMakePointerCheck(const MemberInformation* member, const DeclarationModifierComputations& modifier, const MemberLoadType loadType)
{ {
if (loadType != MemberLoadType::ARRAY_POINTER && loadType != MemberLoadType::POINTER_ARRAY && loadType != MemberLoadType::SINGLE_POINTER) if (loadType != MemberLoadType::ARRAY_POINTER && loadType != MemberLoadType::POINTER_ARRAY && loadType != MemberLoadType::SINGLE_POINTER)
{ {
@ -780,11 +780,11 @@ namespace
}; };
} // namespace } // namespace
std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRender(RenderingContext* context) std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRender(const RenderingContext& context)
{ {
std::vector<CodeTemplateFile> files; std::vector<CodeTemplateFile> files;
auto assetName = context->m_asset->m_definition->m_name; auto assetName = context.m_asset->m_definition->m_name;
utils::MakeStringLowerCase(assetName); utils::MakeStringLowerCase(assetName);
files.emplace_back(std::format("{0}/{0}_mark_db.h", assetName), TAG_HEADER); files.emplace_back(std::format("{0}/{0}_mark_db.h", assetName), TAG_HEADER);
@ -793,7 +793,7 @@ std::vector<CodeTemplateFile> ZoneMarkTemplate::GetFilesToRender(RenderingContex
return files; return files;
} }
void ZoneMarkTemplate::RenderFile(std::ostream& stream, const int fileTag, RenderingContext* context) void ZoneMarkTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
{ {
Template t(stream, context); Template t(stream, context);

4
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneMarkTemplate.h
View File

@ -4,6 +4,6 @@
class ZoneMarkTemplate final : public ICodeTemplate class ZoneMarkTemplate final : public ICodeTemplate
{ {
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
}; };

12
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.cpp
View File

@ -15,7 +15,7 @@ namespace
class Template final : BaseTemplate class Template final : BaseTemplate
{ {
public: public:
Template(std::ostream& stream, RenderingContext* context) Template(std::ostream& stream, const RenderingContext& context)
: BaseTemplate(stream, context) : BaseTemplate(stream, context)
{ {
} }
@ -1119,7 +1119,7 @@ namespace
LINEF("m_stream->MarkFollowing(*{0});", MakeTypeWrittenPtrVarName(def)) LINEF("m_stream->MarkFollowing(*{0});", MakeTypeWrittenPtrVarName(def))
} }
void PrintWritePtrArrayMethod_PointerCheck(const DataDefinition* def, StructureInformation* info, const bool reusable) void PrintWritePtrArrayMethod_PointerCheck(const DataDefinition* def, const StructureInformation* info, const bool reusable)
{ {
LINEF("if (*{0})", MakeTypePtrVarName(def)) LINEF("if (*{0})", MakeTypePtrVarName(def))
LINE("{") LINE("{")
@ -1153,7 +1153,7 @@ namespace
LINE("}") LINE("}")
} }
void PrintWritePtrArrayMethod(const DataDefinition* def, StructureInformation* info, const bool reusable) void PrintWritePtrArrayMethod(const DataDefinition* def, const StructureInformation* info, const bool reusable)
{ {
LINEF("void {0}::WritePtrArray_{1}(const bool atStreamStart, const size_t count)", WriterClassName(m_env.m_asset), MakeSafeTypeName(def)) LINEF("void {0}::WritePtrArray_{1}(const bool atStreamStart, const size_t count)", WriterClassName(m_env.m_asset), MakeSafeTypeName(def))
LINE("{") LINE("{")
@ -1228,11 +1228,11 @@ namespace
}; };
} // namespace } // namespace
std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRender(RenderingContext* context) std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRender(const RenderingContext& context)
{ {
std::vector<CodeTemplateFile> files; std::vector<CodeTemplateFile> files;
auto assetName = context->m_asset->m_definition->m_name; auto assetName = context.m_asset->m_definition->m_name;
for (auto& c : assetName) for (auto& c : assetName)
c = static_cast<char>(tolower(c)); c = static_cast<char>(tolower(c));
@ -1242,7 +1242,7 @@ std::vector<CodeTemplateFile> ZoneWriteTemplate::GetFilesToRender(RenderingConte
return files; return files;
} }
void ZoneWriteTemplate::RenderFile(std::ostream& stream, const int fileTag, RenderingContext* context) void ZoneWriteTemplate::RenderFile(std::ostream& stream, const int fileTag, const RenderingContext& context)
{ {
Template t(stream, context); Template t(stream, context);

4
src/ZoneCodeGeneratorLib/Generating/Templates/ZoneWriteTemplate.h
View File

@ -4,6 +4,6 @@
class ZoneWriteTemplate final : public ICodeTemplate class ZoneWriteTemplate final : public ICodeTemplate
{ {
public: public:
std::vector<CodeTemplateFile> GetFilesToRender(RenderingContext* context) override; std::vector<CodeTemplateFile> GetFilesToRender(const RenderingContext& context) override;
void RenderFile(std::ostream& stream, int fileTag, RenderingContext* context) override; void RenderFile(std::ostream& stream, int fileTag, const RenderingContext& context) override;
}; };